a
    •˜ëjE  ã                   @  s
  d dl mZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlm	Z	 d d	lm
Z
 d
dlmZ d
dlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ e	�rVddlmZ ddlmZ ddlm Z  ddlm!Z! ddl"m#Z# ddl$m%Z% ddlm&Z& ddlm'Z' e
ded �Z(G d!d"„ d"ej!e( ƒZ)G d#d$„ d$eƒZ*d%d&„ Z+G d'd(„ d(ej,e( ƒZ-G d)d*„ d*e-ƒZ.G d+d,„ d,e-ƒZ/G d-d.„ d.e-ƒZ0G d/d0„ d0e-ƒZ1G d1d2„ d2e-ƒZ2G d3d4„ d4e-ƒZ3d5S )6é    )Úannotations)ÚAny)ÚIterable)ÚList)ÚOptional)Úoverload)ÚTuple)ÚTYPE_CHECKING)ÚTypeVaré   )Útypes)ÚARRAYé   )Ú	coercions)Úelements)Ú
expression)Ú	functions)Úroles)Úschema)ÚColumnCollectionConstraint)ÚTEXT)ÚInternalTraversal)Ú_ColumnExpressionArgument)Ú_DDLColumnArgument)ÚClauseElement)ÚColumnElement)ÚOperatorType)Ú
FromClause)Ú_CloneCallableType)Ú_TraverseInternalsTypeÚ_T)Úboundc                   @  sÂ   e Zd ZU dZd ZdZdejfdejfdejfgZ	de
d< edd	d
œdd„ƒZedd	d
œdd„ƒZdd	d
œdd„Zd$dddœdd„Zdddœdd„Zejfddddœdd„Zed d!œd"d#„ƒZdS )%Úaggregate_order_bya  Represent a PostgreSQL aggregate order by expression.

    E.g.::

        from sqlalchemy.dialects.postgresql import aggregate_order_by

        expr = func.array_agg(aggregate_order_by(table.c.a, table.c.b.desc()))
        stmt = select(expr)

    would represent the expression:

    .. sourcecode:: sql

        SELECT array_agg(a ORDER BY b DESC) FROM table;

    Similarly::

        expr = func.string_agg(
            table.c.a, aggregate_order_by(literal_column("','"), table.c.a)
        )
        stmt = select(expr)

    Would represent:

    .. sourcecode:: sql

        SELECT string_agg(a, ',' ORDER BY a) FROM table;

    .. versionchanged:: 1.2.13 - the ORDER BY argument may be multiple terms

    .. seealso::

        :class:`_functions.array_agg`

    Ú
postgresqlÚtargetÚtypeÚorder_byr   Ú_traverse_internalszColumnElement[_T]z_ColumnExpressionArgument[Any]©r$   r&   c                 G  s   d S ©N© ©Úselfr$   r&   r*   r*   úa/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/sqlalchemy/dialects/postgresql/ext.pyÚ__init__Z   s    zaggregate_order_by.__init__z_ColumnExpressionArgument[_T]c                 G  s   d S r)   r*   r+   r*   r*   r-   r.   a   s    c                 G  sn   t  tj|¡| _| jj| _t|ƒ}|  |dkr8tdƒ‚n2|dkrVt  tj|d ¡| _nt	j
|dtjiŽ| _d S )Nr   z)at least one ORDER BY element is requiredr   Z_literal_as_text_role)r   Úexpectr   ÚExpressionElementRoler$   r%   ÚlenÚ	TypeErrorr&   r   Z
ClauseList)r,   r$   r&   Z_lobr*   r*   r-   r.   h   s"    ÿ


ÿÿÿNzOptional[OperatorType]r   )ÚagainstÚreturnc                 C  s   | S r)   r*   )r,   r3   r*   r*   r-   Ú
self_group   s    zaggregate_order_by.self_groupr   zIterable[ClauseElement])Úkwargsr4   c                 K  s   | j | jfS r)   r(   )r,   r6   r*   r*   r-   Úget_children„   s    zaggregate_order_by.get_childrenr   ÚNone)ÚcloneÚkwr4   c                 K  s,   || j fi |¤Ž| _ || jfi |¤Ž| _d S r)   r(   )r,   r9   r:   r*   r*   r-   Ú_copy_internals‡   s    z"aggregate_order_by._copy_internalszList[FromClause])r4   c                 C  s   | j j| jj S r)   )r$   Ú_from_objectsr&   ©r,   r*   r*   r-   r<   �   s    z aggregate_order_by._from_objects)N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__visit_name__Zstringify_dialectr   Zdp_clauseelementZdp_typer'   Ú__annotations__r   r.   r5   r7   r   Z_cloner;   Úpropertyr<   r*   r*   r*   r-   r"   ,   s&   
$ý ÿÿr"   c                      sZ   e Zd ZdZdZdZdZdZe 	ddd¡d	d
ddœdd„ƒZ
‡ fdd„Zddd„Z‡  ZS )ÚExcludeConstraintzäA table-level EXCLUDE constraint.

    Defines an EXCLUDE constraint as described in the `PostgreSQL
    documentation`__.

    __ https://www.postgresql.org/docs/current/static/sql-createtable.html#SQL-CREATETABLE-EXCLUDE

    Zexclude_constraintNFr#   Úwherez:class:`.ExcludeConstraint`z$:paramref:`.ExcludeConstraint.where`zTuple[_DDLColumnArgument, str]r   r8   )r   r:   r4   c                 O  s  g }g }i | _ t|Ž \}}tt tj|¡|ƒD ]V\\}}}	}
}|
durP| |
¡ |dur^|jn|	}|durt|| j |< | |||f¡ q.|| _t	j
| g|¢R | d¡| d¡| d¡| d¡dœŽ | dd¡| _| d	¡}|duròt tj|¡| _| d
i ¡| _dS )a”  
        Create an :class:`.ExcludeConstraint` object.

        E.g.::

            const = ExcludeConstraint(
                (Column("period"), "&&"),
                (Column("group"), "="),
                where=(Column("group") != "some group"),
                ops={"group": "my_operator_class"},
            )

        The constraint is normally embedded into the :class:`_schema.Table`
        construct
        directly, or added later using :meth:`.append_constraint`::

            some_table = Table(
                "some_table",
                metadata,
                Column("id", Integer, primary_key=True),
                Column("period", TSRANGE()),
                Column("group", String),
            )

            some_table.append_constraint(
                ExcludeConstraint(
                    (some_table.c.period, "&&"),
                    (some_table.c.group, "="),
                    where=some_table.c.group != "some group",
                    name="some_table_excl_const",
                    ops={"group": "my_operator_class"},
                )
            )

        The exclude constraint defined in this example requires the
        ``btree_gist`` extension, that can be created using the
        command ``CREATE EXTENSION btree_gist;``.

        :param \*elements:

          A sequence of two tuples of the form ``(column, operator)`` where
          "column" is either a :class:`_schema.Column` object, or a SQL
          expression element (e.g. ``func.int8range(table.from, table.to)``)
          or the name of a column as string, and "operator" is a string
          containing the operator to use (e.g. `"&&"` or `"="`).

          In order to specify a column name when a :class:`_schema.Column`
          object is not available, while ensuring
          that any necessary quoting rules take effect, an ad-hoc
          :class:`_schema.Column` or :func:`_expression.column`
          object should be used.
          The ``column`` may also be a string SQL expression when
          passed as :func:`_expression.literal_column` or
          :func:`_expression.text`

        :param name:
          Optional, the in-database name of this constraint.

        :param deferrable:
          Optional bool.  If set, emit DEFERRABLE or NOT DEFERRABLE when
          issuing DDL for this constraint.

        :param initially:
          Optional string.  If set, emit INITIALLY <value> when issuing DDL
          for this constraint.

        :param info: Optional data dictionary which will be populated into the
            :attr:`.SchemaItem.info` attribute of this object.

            .. versionadded:: 2.0.50

        :param using:
          Optional string.  If set, emit USING <index_method> when issuing DDL
          for this constraint. Defaults to 'gist'.

        :param where:
          Optional SQL expression construct or literal SQL string.
          If set, emit WHERE <predicate> when issuing DDL
          for this constraint.

        :param ops:
          Optional dictionary.  Used to define operator classes for the
          elements; works the same way as that of the
          :ref:`postgresql_ops <postgresql_operator_classes>`
          parameter specified to the :class:`_schema.Index` construct.

          .. versionadded:: 1.3.21

          .. seealso::

            :ref:`postgresql_operator_classes` - general description of how
            PostgreSQL operator classes are specified.

        NÚnameÚ
deferrableÚ	initiallyÚinfo)rG   rH   rI   rJ   ÚusingZgistrF   Úops)Ú	operatorsÚzipr   Z expect_col_expression_collectionr   ZDDLConstraintColumnRoleÚappendrG   Ú_render_exprsr   r.   ÚgetrK   r/   ZStatementOptionRolerF   rL   )r,   r   r:   ÚcolumnsZrender_exprsZexpressionsrM   ÚexprÚcolumnZstrnameZadd_elementÚoperatorrG   rF   r*   r*   r-   r.   £   s@    fÿü

ÿþú
zExcludeConstraint.__init__c                   s&   t ƒ  ˆ ¡ ‡ fdd„| jD ƒ| _d S )Nc                   s0   g | ](\}}}t |tƒs|nˆ j| ||f‘qS r*   )Ú
isinstanceÚstrÚc)Ú.0rS   rG   rU   ©Útabler*   r-   Ú
<listcomp>4  s
   üýz1ExcludeConstraint._set_parent.<locals>.<listcomp>)ÚsuperÚ_set_parentrP   )r,   r[   r:   ©Ú	__class__rZ   r-   r^   1  s    
úzExcludeConstraint._set_parentc                   sJ   ‡ ‡fdd„ˆ j D ƒ}ˆ j|ˆ jˆ jˆ jˆ jˆ jdœŽ}|j ˆ j¡ |S )Nc                   s&   g | ]\}}}t  |ˆ jˆ¡|f‘qS r*   )r   Z_copy_expressionÚparent)rY   rS   Ú_rU   ©r,   Útarget_tabler*   r-   r\   >  s   ýþz+ExcludeConstraint._copy.<locals>.<listcomp>)rG   rH   rI   rF   rK   )	rP   r`   rG   rH   rI   rF   rK   ÚdispatchÚ_update)r,   rd   r:   r   rX   r*   rc   r-   Ú_copy=  s    ûúzExcludeConstraint._copy)N)r>   r?   r@   rA   rB   rF   Úinherit_cacheZcreate_drop_stringify_dialectr   Z_document_text_coercionr.   r^   rg   Ú__classcell__r*   r*   r_   r-   rE   ’   s   	ý 
rE   c                  O  s   t |d< tjj| i |¤ŽS )zÏPostgreSQL-specific form of :class:`_functions.array_agg`, ensures
    return type is :class:`_postgresql.ARRAY` and not
    the plain :class:`_types.ARRAY`, unless an explicit ``type_``
    is passed.

    Z_default_array_type)r   r   ÚfuncÚ	array_agg)Úargr:   r*   r*   r-   rk   Q  s    rk   c                      s    e Zd ZdZ‡ fdd„Z‡  ZS )Ú_regconfig_fnTc                   sr   t |ƒ}t|ƒdkrBtjtj| d¡tˆ dd ƒˆ tj	d�}|g}ng }‡ fdd„|D ƒ}t
ƒ j|| i |¤Ž d S )Nr   r   rG   )rG   Úapply_propagate_attrsÚtype_c              	     s(   g | ] }t jtj|tˆ d dƒˆ d�‘qS ©rG   N)rG   rn   ©r   r/   r   r0   Úgetattr©rY   rX   r=   r*   r-   r\   m  s   ú
üz*_regconfig_fn.__init__.<locals>.<listcomp>)Úlistr1   r   r/   r   r0   Úpoprr   r   Ú	REGCONFIGr]   r.   )r,   Úargsr6   Úinitial_argÚ
addtl_argsr_   r=   r-   r.   _  s    
û
ù	z_regconfig_fn.__init__)r>   r?   r@   rh   r.   ri   r*   r*   r_   r-   rm   \  s   rm   c                   @  s   e Zd ZdZdZejZdS )Úto_tsvectoraÇ  The PostgreSQL ``to_tsvector`` SQL function.

    This function applies automatic casting of the REGCONFIG argument
    to use the :class:`_postgresql.REGCONFIG` datatype automatically,
    and applies a return type of :class:`_postgresql.TSVECTOR`.

    Assuming the PostgreSQL dialect has been imported, either by invoking
    ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL
    engine using ``create_engine("postgresql...")``,
    :class:`_postgresql.to_tsvector` will be used automatically when invoking
    ``sqlalchemy.func.to_tsvector()``, ensuring the correct argument and return
    type handlers are used at compile and execution time.

    .. versionadded:: 2.0.0rc1

    TN)r>   r?   r@   rA   rh   r   ZTSVECTORr%   r*   r*   r*   r-   rz   y  s   rz   c                   @  s   e Zd ZdZdZejZdS )Ú
to_tsqueryaÃ  The PostgreSQL ``to_tsquery`` SQL function.

    This function applies automatic casting of the REGCONFIG argument
    to use the :class:`_postgresql.REGCONFIG` datatype automatically,
    and applies a return type of :class:`_postgresql.TSQUERY`.

    Assuming the PostgreSQL dialect has been imported, either by invoking
    ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL
    engine using ``create_engine("postgresql...")``,
    :class:`_postgresql.to_tsquery` will be used automatically when invoking
    ``sqlalchemy.func.to_tsquery()``, ensuring the correct argument and return
    type handlers are used at compile and execution time.

    .. versionadded:: 2.0.0rc1

    TN©r>   r?   r@   rA   rh   r   ÚTSQUERYr%   r*   r*   r*   r-   r{   �  s   r{   c                   @  s   e Zd ZdZdZejZdS )Úplainto_tsqueryaÒ  The PostgreSQL ``plainto_tsquery`` SQL function.

    This function applies automatic casting of the REGCONFIG argument
    to use the :class:`_postgresql.REGCONFIG` datatype automatically,
    and applies a return type of :class:`_postgresql.TSQUERY`.

    Assuming the PostgreSQL dialect has been imported, either by invoking
    ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL
    engine using ``create_engine("postgresql...")``,
    :class:`_postgresql.plainto_tsquery` will be used automatically when
    invoking ``sqlalchemy.func.plainto_tsquery()``, ensuring the correct
    argument and return type handlers are used at compile and execution time.

    .. versionadded:: 2.0.0rc1

    TNr|   r*   r*   r*   r-   r~   ¥  s   r~   c                   @  s   e Zd ZdZdZejZdS )Úphraseto_tsqueryaÕ  The PostgreSQL ``phraseto_tsquery`` SQL function.

    This function applies automatic casting of the REGCONFIG argument
    to use the :class:`_postgresql.REGCONFIG` datatype automatically,
    and applies a return type of :class:`_postgresql.TSQUERY`.

    Assuming the PostgreSQL dialect has been imported, either by invoking
    ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL
    engine using ``create_engine("postgresql...")``,
    :class:`_postgresql.phraseto_tsquery` will be used automatically when
    invoking ``sqlalchemy.func.phraseto_tsquery()``, ensuring the correct
    argument and return type handlers are used at compile and execution time.

    .. versionadded:: 2.0.0rc1

    TNr|   r*   r*   r*   r-   r   »  s   r   c                   @  s   e Zd ZdZdZejZdS )Úwebsearch_to_tsqueryaá  The PostgreSQL ``websearch_to_tsquery`` SQL function.

    This function applies automatic casting of the REGCONFIG argument
    to use the :class:`_postgresql.REGCONFIG` datatype automatically,
    and applies a return type of :class:`_postgresql.TSQUERY`.

    Assuming the PostgreSQL dialect has been imported, either by invoking
    ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL
    engine using ``create_engine("postgresql...")``,
    :class:`_postgresql.websearch_to_tsquery` will be used automatically when
    invoking ``sqlalchemy.func.websearch_to_tsquery()``, ensuring the correct
    argument and return type handlers are used at compile and execution time.

    .. versionadded:: 2.0.0rc1

    TNr|   r*   r*   r*   r-   r€   Ñ  s   r€   c                      s(   e Zd ZdZdZeZ‡ fdd„Z‡  ZS )Úts_headlinea¾  The PostgreSQL ``ts_headline`` SQL function.

    This function applies automatic casting of the REGCONFIG argument
    to use the :class:`_postgresql.REGCONFIG` datatype automatically,
    and applies a return type of :class:`_types.TEXT`.

    Assuming the PostgreSQL dialect has been imported, either by invoking
    ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL
    engine using ``create_engine("postgresql...")``,
    :class:`_postgresql.ts_headline` will be used automatically when invoking
    ``sqlalchemy.func.ts_headline()``, ensuring the correct argument and return
    type handlers are used at compile and execution time.

    .. versionadded:: 2.0.0rc1

    Tc                   s¨   t |ƒ}t|ƒdk rd}n,t|d tjƒrB|d jjtju rBd}nd}|rxt	j
tj| d¡ˆ tˆ dd ƒtjd�}|g}ng }‡ fdd	„|D ƒ}tƒ j|| i |¤Ž d S )
Né   Fr   Tr   rG   )rn   rG   ro   c              	     s(   g | ] }t jtj|tˆ d dƒˆ d�‘qS rp   rq   rs   r=   r*   r-   r\     s   ú
üz(ts_headline.__init__.<locals>.<listcomp>)rt   r1   rV   r   r   r%   Z_type_affinityr   r}   r   r/   r   r0   ru   rr   rv   r]   r.   )r,   rw   r6   Zhas_regconfigrx   ry   r_   r=   r-   r.   ü  s.    ÿþ
û
ù	zts_headline.__init__)	r>   r?   r@   rA   rh   r   r%   r.   ri   r*   r*   r_   r-   r�   ç  s   r�   N)4Ú
__future__r   Útypingr   r   r   r   r   r   r	   r
   Ú r   Úarrayr   Zsqlr   r   r   r   r   r   Z
sql.schemar   Zsql.sqltypesr   Zsql.visitorsr   Zsql._typingr   r   Zsql.elementsr   r   Zsql.operatorsr   Zsql.selectabler   r   r   r    r"   rE   rk   ZGenericFunctionrm   rz   r{   r~   r   r€   r�   r*   r*   r*   r-   Ú<module>   sP   f @