o

we�9�@s�dZd
dl
Z
d
dlmZ
e
��ZGdd�d�ZGdd�de�ZGdd	�d	e�Z	Gd
d�de�Z
Gdd
�d
e�ZGdd�de�Ze	d�
Z
e	d�
ZdS)zSQL composition utility module
�N)
�
extensionsc@sHeZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dS)�
Composablea6
    Abstract base class for objects that can be used to compose an SQL string.

    `!Composable` objects can be passed directly to `~cursor.execute()`,
    `~cursor.executemany()`, `~cursor.copy_expert()` in place of the query
    string.

    `!Composable` objects can be joined using the ``+`` operator: the result
    will be a `Composed` instance containing the objects joined. The operator
    ``*`` is also supported with an integer argument: the result is a
    `!Composed` instance containing the left argument repeated as many times as
    requested.
    cCs
|
|_dS�
N�
�_wrapped)�self�wrapped�r	�E/home/arjun/projects/env/lib/python3.10/site-packages/psycopg2/sql.py�__init__1�

zComposable.__init__c

Cs|jj
�d
|j�d�S)N�
(�
))�	__class__�__name__r�
rr	r	r
�__repr__4s
zComposable.__repr__c
Cst�
)
aj

        Return the string value of the object.

        :param context: the context to evaluate the string into.
        :type context: `connection` or `cursor`

        The method is automatically invoked by `~cursor.execute()`,
        `~cursor.executemany()`, `~cursor.copy_expert()` if a `!Composable` is
        passed instead of the query string.
        )
�NotImplementedError�r�contextr	r	r
�	as_string7szComposable.as_stringcCs:t|
t
�rt
|g
�
|
St|
t�rt
|g
�
t
|
g
�
StSr)�
isinstance�Composedr�NotImplemented�r�otherr	r	r
�__add__Ds






zComposable.__add__cCst|g
|
�
Sr)
r)r�
nr	r	r
�__mul__Ls
zComposable.__mul__cCst|�
t|
�
uo
|j
|
j
kSr)�typerrr	r	r
�__eq__Os
zComposable.__eq__cCs|�|
�
Sr)
r rr	r	r
�__ne__Rs
zComposable.__ne__N)r�
__module__�__qualname__�__doc__rrrrrr r!r	r	r	r
r#s


rcsLeZ
dZd
Z�f
dd�Zedd��
Zdd�Zdd	�Zd
d�Z	dd
�Z
�ZS)ra
    A `Composable` object made of a sequence of `!Composable`.

    The object is usually created using `!Composable` operators and methods.
    However it is possible to create a `!Composed` directly specifying a
    sequence of `!Composable` as arguments.

    Example::

        >>> comp = sql.Composed(
        ...     [sql.SQL("insert into "), sql.Identifier("table")])
        >>> print(comp.as_string(conn))
        insert into "table"

    `!Composed` objects are iterable (so they can be used in `SQL.join` for
    instance).
    csBg}|
D]}t|t
�std
|�d��
�
|�|�

qt��|�

dS)Nz*Composed elements must be Composable, got z instead)rr�	TypeError�append�superr)r�seqr�
i�
rr	r
rhs






�zComposed.__init__c

C�
t|j
�
S)
z+The list of the content of the `!Composed`.)�listrrr	r	r
r(rs
zComposed.seqcCs*g}|jD]
}|�
|�|
�
�

qd
�|�
S)N�)rr&r�join)rr�rvr)r	r	r
rws





zComposed.as_stringc

Cr+r)�iterrrr	r	r
�__iter__}rzComposed.__iter__cCs8t|
t
�r
t
|j|
j�
St|
t�rt
|j|
g
�
StSr)rrrrrrr	r	r
r�s






zComposed.__add__cCs0t|
t
�r
t|
�
}
n	t|
t�std
�
�
|
�|�
S)a|

        Return a new `!Composed` interposing the *joiner* with the `!Composed` items.

        The *joiner* must be a `SQL` or a string which will be interpreted as
        an `SQL`.

        Example::

            >>> fields = sql.Identifier('foo') + sql.Identifier('bar')  # a Composed
            >>> print(fields.join(', ').as_string(conn))
            "foo", "bar"

        z3Composed.join() argument must be a string or an SQL)r�str�SQLr%r.)r�joinerr	r	r
r.�s






�
z
Composed.join)rr"r#r$r�propertyr(rr1rr.�
__classcell__r	r	r*r
rVs



rcsDeZ
dZd
Z�f
dd�Zedd��
Zdd�Zdd	�Zd
d�Z	�Z
S)r3aA
    A `Composable` representing a snippet of SQL statement.

    `!SQL` exposes `join()` and `format()` methods useful to create a template
    where to merge variable parts of a query (for instance field or table
    names).

    The *string* doesn't undergo any form of escaping, so it is not suitable to
    represent variable identifiers or values: you should only use it to pass
    constant strings representing templates or snippets of SQL statements; use
    other objects such as `Identifier` or `Literal` to represent variable
    parts.

    Example::

        >>> query = sql.SQL("select {0} from {1}").format(
        ...    sql.SQL(', ').join([sql.Identifier('foo'), sql.Identifier('bar')]),
        ...    sql.Identifier('table'))
        >>> print(query.as_string(conn))
        select "foo", "bar" from "table"
    cs"t|
t
�s	td
�
�
t��|
�

dS)NzSQL values must be strings)rr2r%r'r)r�stringr*r	r
r�s



zSQL.__init__c


C�|jS)
z(The string wrapped by the `!SQL` object.rrr	r	r
r7��z
SQL.stringc
Cr8rrrr	r	r
r�s
z
SQL.as_stringc
	Os�g}d
}t�
|j�
D]S\}}}}|rtd�
�
|rtd�
�
|r%|�t|�
�

|dur*q
|��r@|r4td�
�
|�|
t|�
�

d}q
|sV|durJtd�
�
|�|
|�

|d7}q
|�||�

q
t|�
S)a^
        Merge `Composable` objects into a template.

        :param `Composable` args: parameters to replace to numbered
            (``{0}``, ``{1}``) or auto-numbered (``{}``) placeholders
        :param `Composable` kwargs: parameters to replace to named (``{name}``)
            placeholders
        :return: the union of the `!SQL` string with placeholders replaced
        :rtype: `Composed`

        The method is similar to the Python `str.format()` method: the string
        template supports auto-numbered (``{}``), numbered (``{0}``,
        ``{1}``...), and named placeholders (``{name}``), with positional
        arguments replacing the numbered placeholders and keywords replacing
        the named ones. However placeholder modifiers (``{0!r}``, ``{0:<10}``)
        are not supported. Only `!Composable` objects can be passed to the
        template.

        Example::

            >>> print(sql.SQL("select * from {} where {} = %s")
            ...     .format(sql.Identifier('people'), sql.Identifier('id'))
            ...     .as_string(conn))
            select * from "people" where "id" = %s

            >>> print(sql.SQL("select * from {tbl} where {pkey} = %s")
            ...     .format(tbl=sql.Identifier('people'), pkey=sql.Identifier('id'))
            ...     .as_string(conn))
            select * from "people" where "id" = %s

        r
z(no format specification supported by SQLz%no format conversion supported by SQLNz6cannot switch from automatic field numbering to manualz6cannot switch from manual field numbering to automatic�
)	�
_formatter�parser�
ValueErrorr&r3�isdigit�intr)	r�args�kwargsr/�autonum�pre�name�spec�convr	r	r
�format�s6 











�



�

z
SQL.formatcCs^g}t|
�
}z	|�
t|�
�

Wnty


Yt|�
Sw|D]}|�
|�

|�
|�

qt|�
S)
a
        Join a sequence of `Composable`.

        :param seq: the elements to join.
        :type seq: iterable of `!Composable`

        Use the `!SQL` object's *string* to separate the elements in *seq*.
        Note that `Composed` objects are iterable too, so they can be used as
        argument for this method.

        Example::

            >>> snip = sql.SQL(', ').join(
            ...     sql.Identifier(n) for n in ['foo', 'bar', 'baz'])
            >>> print(snip.as_string(conn))
            "foo", "bar", "baz"
        )r0r&�next�
StopIterationr)rr(r/�itr)r	r	r
r.
s




�


zSQL.join)rr"r#r$rr5r7rrGr.r6r	r	r*r
r3�s


@r3csHeZ
dZd
Z�f
dd�Zedd��
Zedd��
Zdd	�Zd
d�Z	�Z
S)�
Identifiera*
    A `Composable` representing an SQL identifier or a dot-separated sequence.

    Identifiers usually represent names of database objects, such as tables or
    fields. PostgreSQL identifiers follow `different rules`__ than SQL string
    literals for escaping (e.g. they use double quotes instead of single).

    .. __: https://www.postgresql.org/docs/current/static/sql-syntax-lexical.html#         SQL-SYNTAX-IDENTIFIERS

    Example::

        >>> t1 = sql.Identifier("foo")
        >>> t2 = sql.Identifier("ba'r")
        >>> t3 = sql.Identifier('ba"z')
        >>> print(sql.SQL(', ').join([t1, t2, t3]).as_string(conn))
        "foo", "ba'r", "ba""z"

    Multiple strings can be passed to the object to represent a qualified name,
    i.e. a dot-separated sequence of identifiers.

    Example::

        >>> query = sql.SQL("select {} from {}").format(
        ...     sql.Identifier("table", "field"),
        ...     sql.Identifier("schema", "table"))
        >>> print(query.as_string(conn))
        select "table"."field" from "schema"."table"

    c
s8|
std
�
�
|
D]}t
|t�std�
�
qt��|
�

dS)NzIdentifier cannot be emptyz$SQL identifier parts must be strings)r%rr2r'r)r�strings�
sr*r	r
rA
s




�zIdentifier.__init__c


Cr8)
z5A tuple with the strings wrapped by the `Identifier`.rrr	r	r
rLK
r9zIdentifier.stringsc

Cs t|j
�
d
kr|j
dStd�
�
)z0The string wrapped by the `Identifier`.
        r:r
z2the Identifier wraps more than one than one string)�lenr�AttributeErrorrr	r	r
r7P
s



�zIdentifier.stringc

Cs"|jj
�d
d�tt|j��
�d�S)Nr
z, r)rrr.�map�reprrrr	r	r
rZ
s"
zIdentifier.__repr__csd
��f
dd�|j
D�
�
S)N�
.c
3s�|]	}
t�
|
��V
qdSr)�ext�quote_ident)�.0rM�
rr	r
�	<genexpr>^
s�z'Identifier.as_string.<locals>.<genexpr>)r.rrr	rVr
r]
s
zIdentifier.as_string)rr"r#r$rr5rLr7rrr6r	r	r*r
rK"
s





	rKc@s$eZ
dZd
Zedd��
Zdd�ZdS)�Literala�
    A `Composable` representing an SQL value to include in a query.

    Usually you will want to include placeholders in the query and pass values
    as `~cursor.execute()` arguments. If however you really really need to
    include a literal value in the query you can use this object.

    The string returned by `!as_string()` follows the normal :ref:`adaptation
    rules <python-types-adaptation>` for Python objects.

    Example::

        >>> s1 = sql.Literal("foo")
        >>> s2 = sql.Literal("ba'r")
        >>> s3 = sql.Literal(42)
        >>> print(sql.SQL(', ').join([s1, s2, s3]).as_string(conn))
        'foo', 'ba''r', 42

    c


Cr8)
z%The object wrapped by the `!Literal`.rrr	r	r
ru
r9zLiteral.wrappedcCsvt|
t
j�r	|
}nt|
t
j�r|
j}ntd
�
�
t
�|j�
}t|d�r'|�|�

|�	�}t|t
�r9|�t
j|j
�
}|S)Nz(context must be a connection or a cursor�prepare)rrS�
connection�cursorr%�adaptr�hasattrrY�	getquoted�bytes�decode�	encodings�encoding)rr�conn�
ar/r	r	r
rz
s









zLiteral.as_stringN)rr"r#r$r5rrr	r	r	r
rXa
s



rXcs>eZ
dZd
Zd�f
dd�	Zedd��
Zdd�Zd	d
�Z�Z	S)�Placeholdera�A `Composable` representing a placeholder for query parameters.

    If the name is specified, generate a named placeholder (e.g. ``%(name)s``),
    otherwise generate a positional placeholder (e.g. ``%s``).

    The object is useful to generate SQL queries with a variable number of
    arguments.

    Examples::

        >>> names = ['foo', 'bar', 'baz']

        >>> q1 = sql.SQL("insert into table ({}) values ({})").format(
        ...     sql.SQL(', ').join(map(sql.Identifier, names)),
        ...     sql.SQL(', ').join(sql.Placeholder() * len(names)))
        >>> print(q1.as_string(conn))
        insert into table ("foo", "bar", "baz") values (%s, %s, %s)

        >>> q2 = sql.SQL("insert into table ({}) values ({})").format(
        ...     sql.SQL(', ').join(map(sql.Identifier, names)),
        ...     sql.SQL(', ').join(map(sql.Placeholder, names)))
        >>> print(q2.as_string(conn))
        insert into table ("foo", "bar", "baz") values (%(foo)s, %(bar)s, %(baz)s)

    NcsHt|
t
�rd
|
vrtd|
���
�
n|
du
rtd|
���
�
t��|
�

dS)Nrzinvalid name: z%expected string or None as name, got )rr2r=r%r'r)rrDr*r	r
r�
s



�
zPlaceholder.__init__c


Cr8)
zThe name of the `!Placeholder`.rrr	r	r
rD�
r9zPlaceholder.namec

Cs.|jdur|j
j�d
�S|j
j�d|j�d�S)Nz()r
r)rrrrr	r	r
r�
s


zPlaceholder.__repr__cCs|jdu
rd
|j�d�SdS)Nz%(z)sz%srrr	r	r
r�
s


zPlaceholder.as_stringr)
rr"r#r$rr5rDrrr6r	r	r*r
re�
s



re�NULL�DEFAULT)r$r7�psycopg2rrS�	Formatterr;rrr3rKrXrerfrgr	r	r	r
�<module>
s3I?-8