https://t.me/RX1948
Server : Apache
System : Linux iad1-shared-b8-43 6.6.49-grsec-jammy+ #10 SMP Thu Sep 12 23:23:08 UTC 2024 x86_64
User : dh_edsupp ( 6597262)
PHP Version : 8.2.26
Disable Function : NONE
Directory :  /lib/python3/dist-packages/psycopg2/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Current File : //lib/python3/dist-packages/psycopg2/__pycache__/sql.cpython-310.pyc
o


��a�9�@s�dZddlZddlmZe��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@sHeZdZdZdd�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	�./usr/lib/python3/dist-packages/psycopg2/sql.py�__init__1�
zComposable.__init__cCs|jj�d|j�d�S)N�(�))�	__class__�__name__r�rr	r	r
�__repr__4szComposable.__repr__cCst�)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__LszComposable.__mul__cCst|�t|�uo
|j|jkSr)�typerrr	r	r
�__eq__OszComposable.__eq__cCs|�|�Sr)r rr	r	r
�__ne__RszComposable.__ne__N)r�
__module__�__qualname__�__doc__rrrrrr r!r	r	r	r
r#s

rcsLeZdZdZ�fdd�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__cC�
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_stringcCr+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

rcsDeZdZdZ�fdd�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__cC�|jS)z(The string wrapped by the `!SQL` object.rrr	r	r
r7��z
SQL.stringcCr8rrrr	r	r
r�sz
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

        rz(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tyYt|�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
@r3csHeZdZdZ�fdd�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"

    cs8|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
rAs
�zIdentifier.__init__cCr8)z5A tuple with the strings wrapped by the `Identifier`.rrr	r	r
rLKr9zIdentifier.stringscCs t|j�dkr|jdStd��)z0The string wrapped by the `Identifier`.
        r:rz2the Identifier wraps more than one than one string)�lenr�AttributeErrorrr	r	r
r7Ps

�zIdentifier.stringcCs"|jj�dd�tt|j���d�S)Nr
z, r)rrr.�map�reprrrr	r	r
rZs"zIdentifier.__repr__csd��fdd�|jD��S)N�.c3s�|]	}t�|��VqdSr)�ext�quote_ident)�.0rM�rr	r
�	<genexpr>^s�z'Identifier.as_string.<locals>.<genexpr>)r.rrr	rVr
r]szIdentifier.as_string)rr"r#r$rr5rLr7rrr6r	r	r*r
rK"s


	rKc@s$eZdZdZedd��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

    cCr8)z%The object wrapped by the `!Literal`.rrr	r	r
rur9zLiteral.wrappedcCsvt|tj�r	|}nt|tj�r|j}ntd��t�|j�}t|d�r'|�|�|�	�}t|t
�r9|�tj|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
rzs


zLiteral.as_stringN)rr"r#r$r5rrr	r	r	r
rXas

rXcs>eZdZdZd�fdd�	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|durtd|����t��|�dS)Nrzinvalid name: z%expected string or None as name, got )rr2r=r%r'r)rrDr*r	r
r�s
�zPlaceholder.__init__cCr8)zThe name of the `!Placeholder`.rrr	r	r
rD�r9zPlaceholder.namecCs.|jdur|jj�d�S|jj�d|j�d�S)Nz()r
r)rrrrr	r	r
r�s
zPlaceholder.__repr__cCs|jdur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

https://t.me/RX1948 - 2025