B

*��]:�@s�dZd
dl
Z
d
dlmZ
d
dlmZmZ
e
��Z	Gdd�de
�ZGdd�de�ZGd	d
�d
e�Z
Gdd�de�ZGd
d�de�ZGdd�de�Ze
d�
Ze
d�
ZdS)zSQL composition utility module
�N)
�
extensions)�PY3�string_typesc@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	�?/opt/alt/python37/lib64/python3.7/site-packages/psycopg2/sql.py�__init__1s
zComposable.__init__c

Csd
|jj
|jfS)Nz%s(%r))�	__class__�__name__r)
rr	r	r
�__repr__4s
zComposable.__repr__c
Cst�
d
S)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.
        N)
�NotImplementedError)r�contextr	r	r
�	as_string7szComposable.as_stringcCs>t|
t
�rt
|g
�
|
St|
t�r6t
|g
�
t
|
g
�
StSdS)
N)�
isinstance�Composedr�NotImplemented)r�otherr	r	r
�__add__Ds






zComposable.__add__cCst|g
|
�
S)
N)
r)r�
nr	r	r
�__mul__Ls
zComposable.__mul__cCst|�
t|
�
ko|j
|
j
kS)
N)�typer)rrr	r	r
�__eq__Os
zComposable.__eq__cCs|�|
�
S)
N)
r)rrr	r	r
�__ne__Rs
zComposable.__ne__N)r
�
__module__�__qualname__�__doc__rrrrrrrr	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).
    csFg}x,|
D]$}t|t
�s$td
|�
�
|�|�

q
Wtt|��|�

dS)Nz4Composed elements must be Composable, got %r instead)rr�	TypeError�append�superrr)r�seqr�
i)
rr	r
rhs








zComposed.__init__c

Cs
t|j
�
S)
z+The list of the content of the `!Composed`.)�listr)
rr	r	r
r"rszComposed.seqcCs.g}x|jD]}|�
|�|
�
�

qWd
�|�
S)N�)rr r�join)rr�rvr#r	r	r
rws



zComposed.as_stringc

Cs
t|j
�
S)
N)�iterr)
rr	r	r
�__iter__}s
zComposed.__iter__cCs<t|
t
�rt
|j|
j�
St|
t�r4t
|j|
g
�
StSdS)
N)rrrrr)rrr	r	r
r�s






zComposed.__add__cCs0t|
t
�rt|
�
}
nt|
t�s&td
�
�
|
�|�
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)rr�SQLrr&)rZjoinerr	r	r
r&�s






z
Composed.join)r
rrrr�propertyr"rr)rr&�
__classcell__r	r	)
rr
rVs

rcsDeZ
dZd
Z�f
dd�Zedd��
Zdd�Zdd	�Zd
d�Z	�Z
S)r*aA
    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
�std
�
�
tt|��|
�

dS)NzSQL values must be strings)rrrr!r*r)r�string)
rr	r
r�s



zSQL.__init__c


Cs|jS)
z(The string wrapped by the `!SQL` object.)
r)
rr	r	r
r-�sz
SQL.stringc
Cs|jS)
N)
r)rrr	r	r
r�s
z
SQL.as_stringc
	Os�g}d
}x�t�
|j�
D]�\}}}}|r.td�
�
|r:td�
�
|rL|�t|�
�

|dkrVq|��r�|rjtd�
�
|�|
t|�
�

d}q|s�|dkr�td�
�
|�|
|�

|d7}q|�||�

qWt|�
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 r*�isdigit�intr)	r�args�kwargsr'ZautonumZpre�name�specZconvr	r	r
�format�s2 



















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

Wntk
r2


Yn$Xx |D]}|�
|�

|�
|�

q:Wt|�
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"
        )r(r �next�
StopIterationr)rr"r'�itr#r	r	r
r&
s








zSQL.join)r
rrrrr+r-rr8r&r,r	r	)
rr
r*�s
@r*csHeZ
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
s@|
std
�
�
x|
D]}t
|t�std�
�
qWtt|��|
�

dS)NzIdentifier cannot be emptyz$SQL identifier parts must be strings)rrrr!r<r)r�strings�
s)
rr	r
rA
s





zIdentifier.__init__c


Cs|jS)
z5A tuple with the strings wrapped by the `Identifier`.)
r)
rr	r	r
r=K
szIdentifier.stringsc

Cs$t|j
�
d
kr|j
dStd�
�
dS)z0The string wrapped by the `Identifier`.
        r.r
z2the Identifier wraps more than one than one stringN)�lenr�AttributeError)
rr	r	r
r-P
s


zIdentifier.stringc

Csd
|jj
d�tt|j��
fS)Nz%s(%s)z, )rr
r&�map�reprr)
rr	r	r
rZ
s


zIdentifier.__repr__csd
��f
dd�|j
D�
�
S)N�
.c
3s|]}
t�
|
��V
qdS)
N)�extZquote_ident)�.0r>)
rr	r
�	<genexpr>`
sz'Identifier.as_string.<locals>.<genexpr>)r&r)rrr	)
rr
r_
s
zIdentifier.as_string)r
rrrrr+r=r-rrr,r	r	)
rr
r<"
s


r<c@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


Cs|jS)
z%The object wrapped by the `!Literal`.)
r)
rr	r	r
rw
szLiteral.wrappedcCszt|
t
j�r|
}nt|
t
j�r&|
j}ntd
�
�
t
�|j�
}t|d�rN|�|�

|�	�}t
rvt|t�rv|�t
j
|j�
}|S)Nz(context must be a connection or a cursor�prepare)rrDZ
connectionZcursorrZadaptr�hasattrrHZ	getquotedr�bytes�decodeZ	encodings�encoding)rrZconn�
ar'r	r	r
r|
s








zLiteral.as_stringN)r
rrrr+rrr	r	r	r
rGc
s
rGcs>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
�r d
|
kr4td|
�
�
n|
dk	r4td|
�
�
tt|��|
�

dS)N�
)zinvalid name: %rz'expected string or None as name, got %r)rrr1rr!rNr)rr6)
rr	r
r�
s




zPlaceholder.__init__c


Cs|jS)
zThe name of the `!Placeholder`.)
r)
rr	r	r
r6�
szPlaceholder.namec

Csd
|jdk	r|jndf
S)NzPlaceholder(%r)r%)
r)
rr	r	r
r�
s

zPlaceholder.__repr__cCs|jdk	rd
|jSdSdS)Nz%%(%s)sz%s)
r)rrr	r	r
r�
s



zPlaceholder.as_string)
N)
r
rrrrr+r6rrr,r	r	)
rr
rN�
s

rN�NULL�DEFAULT)rr-Zpsycopg2rrDZpsycopg2.compatrrZ	Formatterr/�objectrrr*r<rGrNrPrQr	r	r	r
�<module>s
3IA-6