U
    h<B                     @  s  d dl mZ d dl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% 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.ej/fd$d%d&d'd(d)d*Zej/fd$d%d&d'd(d+d,Z0G d-d. d.ej1e. Z2G d/d0 d0ej3e. Z3d1d2d3d4d5Z4dS )6    )annotationsN)Any)Iterable)Optional)Sequence)TYPE_CHECKING)TypeVar)Union   )CONTAINED_BY)CONTAINS)OVERLAP   )types)util)
expression)	operators)InternalTraversal)Dialect)_ColumnExpressionArgument)_TypeEngineArgument)ColumnElement)Grouping)BindParameter)OperatorType)_SelectIterable)_BindProcessorType)_LiteralProcessorType)_ResultProcessorType)
TypeEngine)_TraverseInternalsType)Self_T)bound
typing_Anyz_ColumnExpressionArgument[_T]r   ColumnElement[bool])otherarrexproperatorreturnc                 C  s   | | |S )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method.
    See that method for details.

    )anyr&   r'   r(    r,   H/tmp/pip-unpacked-wheel-y9ln43lq/sqlalchemy/dialects/postgresql/array.pyr   1   s    
r   c                 C  s   | | |S )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method.
    See that method for details.

    )allr+   r,   r,   r-   All>   s    
r/   c                      s   e Zd ZU dZd ZdZdejfdejfgZ	de
d< ddd	d
dd fddZeddddZd ddddddddZd!dddddZ  ZS )"arraya  A PostgreSQL ARRAY literal.

    This is used to produce ARRAY literals in SQL expressions, e.g.::

        from sqlalchemy.dialects.postgresql import array
        from sqlalchemy.dialects import postgresql
        from sqlalchemy import select, func

        stmt = select(array([1, 2]) + array([3, 4, 5]))

        print(stmt.compile(dialect=postgresql.dialect()))

    Produces the SQL:

    .. sourcecode:: sql

        SELECT ARRAY[%(param_1)s, %(param_2)s] ||
            ARRAY[%(param_3)s, %(param_4)s, %(param_5)s]) AS anon_1

    An instance of :class:`.array` will always have the datatype
    :class:`_types.ARRAY`.  The "inner" type of the array is inferred from the
    values present, unless the :paramref:`_postgresql.array.type_` keyword
    argument is passed::

        array(["foo", "bar"], type_=CHAR)

    When constructing an empty array, the :paramref:`_postgresql.array.type_`
    argument is particularly important as PostgreSQL server typically requires
    a cast to be rendered for the inner type in order to render an empty array.
    SQLAlchemy's compilation for the empty array will produce this cast so
    that::

        stmt = array([], type_=Integer)
        print(stmt.compile(dialect=postgresql.dialect()))

    Produces:

    .. sourcecode:: sql

        ARRAY[]::INTEGER[]

    As required by PostgreSQL for empty arrays.

    .. versionadded:: 2.0.40 added support to render empty PostgreSQL array
       literals with a required cast.

    Multidimensional arrays are produced by nesting :class:`.array` constructs.
    The dimensionality of the final :class:`_types.ARRAY`
    type is calculated by
    recursively adding the dimensions of the inner :class:`_types.ARRAY`
    type::

        stmt = select(
            array(
                [array([1, 2]), array([3, 4]), array([column("q"), column("x")])]
            )
        )
        print(stmt.compile(dialect=postgresql.dialect()))

    Produces:

    .. sourcecode:: sql

        SELECT ARRAY[
            ARRAY[%(param_1)s, %(param_2)s],
            ARRAY[%(param_3)s, %(param_4)s],
            ARRAY[q, x]
        ] AS anon_1

    .. versionadded:: 1.3.6 added support for multidimensional array literals

    .. seealso::

        :class:`_postgresql.ARRAY`

    Z
postgresqlclausestyper    _traverse_internalsN)type_zIterable[_T]z!Optional[_TypeEngineArgument[_T]]r$   )r1   r4   kwc                  sx   t  jtjf|| |dk	r"|n| jr4| jd jntj}t|t	rjt	|j
|jdk	r^|jd ndd| _n
t	|| _dS )a  Construct an ARRAY literal.

        :param clauses: iterable, such as a list, containing elements to be
         rendered in the array
        :param type\_: optional type.  If omitted, the type is inferred
         from the contents of the array.

        Nr   r
      )
dimensions)super__init__r   Zcomma_opr1   r2   sqltypesZNULLTYPE
isinstanceARRAY	item_typer7   )selfr1   r4   r5   Z	main_type	__class__r,   r-   r9      s    

	zarray.__init__r   r)   c                 C  s   | fS Nr,   r>   r,   r,   r-   _select_iterable   s    zarray._select_iterableFr   zOptional[TypeEngine[_T]]boolzBindParameter[_T])r(   objr4   _assume_scalarr)   c                   sD   |s t jkr&tjd | jddS t fdd|D S d S )NT)Z_compared_to_operatorr4   Z_compared_to_typeuniquec                   s   g | ]}j  |d dqS )T)rG   r4   )_bind_param).0or(   r>   r4   r,   r-   
<listcomp>   s      z%array._bind_param.<locals>.<listcomp>)r   getitemr   r   r2   r0   )r>   r(   rF   r4   rG   r,   rL   r-   rI      s    
zarray._bind_paramzOptional[OperatorType]zUnion[Self, Grouping[_T]])againstr)   c                 C  s&   |t jt jt jfkrt| S | S d S rB   )r   Zany_opZall_oprN   r   r   )r>   rO   r,   r,   r-   
self_group   s    
zarray.self_group)NF)N)__name__
__module____qualname____doc__Z__visit_name__Zstringify_dialectr   Zdp_clauseelement_tupleZdp_typer3   __annotations__r9   propertyrD   rI   rP   __classcell__r,   r,   r?   r-   r0   K   s   
M	#   r0   c                   @  s   e Zd ZdZdddddddd	ZG d
d dejje ZeZ	e
jddddZdddddZdddddZddddddZdS )r<   an
  PostgreSQL ARRAY type.

    The :class:`_postgresql.ARRAY` type is constructed in the same way
    as the core :class:`_types.ARRAY` type; a member type is required, and a
    number of dimensions is recommended if the type is to be used for more
    than one dimension::

        from sqlalchemy.dialects import postgresql

        mytable = Table(
            "mytable",
            metadata,
            Column("data", postgresql.ARRAY(Integer, dimensions=2)),
        )

    The :class:`_postgresql.ARRAY` type provides all operations defined on the
    core :class:`_types.ARRAY` type, including support for "dimensions",
    indexed access, and simple matching such as
    :meth:`.types.ARRAY.Comparator.any` and
    :meth:`.types.ARRAY.Comparator.all`.  :class:`_postgresql.ARRAY`
    class also
    provides PostgreSQL-specific methods for containment operations, including
    :meth:`.postgresql.ARRAY.Comparator.contains`
    :meth:`.postgresql.ARRAY.Comparator.contained_by`, and
    :meth:`.postgresql.ARRAY.Comparator.overlap`, e.g.::

        mytable.c.data.contains([1, 2])

    Indexed access is one-based by default, to match that of PostgreSQL;
    for zero-based indexed access, set
    :paramref:`_postgresql.ARRAY.zero_indexes`.

    Additionally, the :class:`_postgresql.ARRAY`
    type does not work directly in
    conjunction with the :class:`.ENUM` type.  For a workaround, see the
    special type at :ref:`postgresql_array_of_enum`.

    .. container:: topic

        **Detecting Changes in ARRAY columns when using the ORM**

        The :class:`_postgresql.ARRAY` type, when used with the SQLAlchemy ORM,
        does not detect in-place mutations to the array. In order to detect
        these, the :mod:`sqlalchemy.ext.mutable` extension must be used, using
        the :class:`.MutableList` class::

            from sqlalchemy.dialects.postgresql import ARRAY
            from sqlalchemy.ext.mutable import MutableList


            class SomeOrmClass(Base):
                # ...

                data = Column(MutableList.as_mutable(ARRAY(Integer)))

        This extension will allow "in-place" changes such to the array
        such as ``.append()`` to produce events which will be detected by the
        unit of work.  Note that changes to elements **inside** the array,
        including subarrays that are mutated in place, are **not** detected.

        Alternatively, assigning a new array value to an ORM element that
        replaces the old one will always trigger a change event.

    .. seealso::

        :class:`_types.ARRAY` - base array type

        :class:`_postgresql.array` - produces a literal array value.

    FNz_TypeEngineArgument[_T]rE   zOptional[int])r=   as_tupler7   zero_indexesc                 C  s>   t |trtdt |tr"| }|| _|| _|| _|| _dS )a-  Construct an ARRAY.

        E.g.::

          Column("myarray", ARRAY(Integer))

        Arguments are:

        :param item_type: The data type of items of this array. Note that
          dimensionality is irrelevant here, so multi-dimensional arrays like
          ``INTEGER[][]``, are constructed as ``ARRAY(Integer)``, not as
          ``ARRAY(ARRAY(Integer))`` or such.

        :param as_tuple=False: Specify whether return results
          should be converted to tuples from lists. DBAPIs such
          as psycopg2 return lists by default. When tuples are
          returned, the results are hashable.

        :param dimensions: if non-None, the ARRAY will assume a fixed
         number of dimensions.  This will cause the DDL emitted for this
         ARRAY to include the exact number of bracket clauses ``[]``,
         and will also optimize the performance of the type overall.
         Note that PG arrays are always implicitly "non-dimensioned",
         meaning they can store any number of dimensions no matter how
         they were declared.

        :param zero_indexes=False: when True, index values will be converted
         between Python zero-based and PostgreSQL one-based indexes, e.g.
         a value of one will be added to all index values before passing
         to the database.

        zUDo not nest ARRAY types; ARRAY(basetype) handles multi-dimensional arrays of basetypeN)r;   r<   
ValueErrorr2   r=   rX   r7   rY   )r>   r=   rX   r7   rY   r,   r,   r-   r9   5  s    '

zARRAY.__init__c                   @  sB   e Zd ZdZddddddZddddd	Zdddd
dZdS )zARRAY.Comparatora*  Define comparison operations for :class:`_types.ARRAY`.

        Note that these operations are in addition to those provided
        by the base :class:`.types.ARRAY.Comparator` class, including
        :meth:`.types.ARRAY.Comparator.any` and
        :meth:`.types.ARRAY.Comparator.all`.

        r$   r%   )r&   kwargsr)   c                 K  s   | j t|tjdS )zBoolean expression.  Test if elements are a superset of the
            elements of the argument array expression.

            kwargs may be ignored by this operator but are required for API
            conformance.
            Zresult_type)operater   r:   Boolean)r>   r&   r[   r,   r,   r-   containsr  s    	zARRAY.Comparator.contains)r&   r)   c                 C  s   | j t|tjdS )zBoolean expression.  Test if elements are a proper subset of the
            elements of the argument array expression.
            r\   )r]   r   r:   r^   r>   r&   r,   r,   r-   contained_by}  s
      zARRAY.Comparator.contained_byc                 C  s   | j t|tjdS )zuBoolean expression.  Test if array has elements in common with
            an argument array expression.
            r\   )r]   r   r:   r^   r`   r,   r,   r-   overlap  s    zARRAY.Comparator.overlapN)rQ   rR   rS   rT   r_   ra   rb   r,   r,   r,   r-   
Comparatorh  s   	rc   rA   c                 C  s   t | jtjo| jjS rB   )r;   r=   r:   EnumZnative_enumrC   r,   r,   r-   _against_native_enum  s    zARRAY._against_native_enumr   z#Optional[_LiteralProcessorType[_T]])dialectr)   c                   sJ   j ||  d krd S dddddddd fdd	}|S )
NzIterable[typing_Any]str)elementsr)   c                 S  s   dd |  dS )NzARRAY[z, ])join)rh   r,   r,   r-   to_str  s    z'ARRAY.literal_processor.<locals>.to_strSequence[typing_Any]valuer)   c                   s    |  j}|S rB   )_apply_item_processorr7   rn   inner	item_procr>   rk   r,   r-   process  s       z(ARRAY.literal_processor.<locals>.process)r=   dialect_implliteral_processorr>   rf   rt   r,   rr   r-   rv     s    zARRAY.literal_processorz2Optional[_BindProcessorType[Sequence[typing_Any]]]c                   s,   j || ddd fdd}|S )NOptional[Sequence[typing_Any]]zOptional[list[typing_Any]]rm   c                   s"   | d kr| S  |  jtS d S rB   )ro   r7   listrn   rs   r>   r,   r-   rt     s       z%ARRAY.bind_processor.<locals>.process)r=   ru   bind_processorrw   r,   r{   r-   r|     s
    
zARRAY.bind_processorobjectz*_ResultProcessorType[Sequence[typing_Any]])rf   coltyper)   c                   sl   j |||dddfdd}jrh|tddddfd	d
 ddd fdd}|S )Nrl   rx   rm   c                   s,   | d kr| S  |  jjr"tntS d S rB   )ro   r7   rX   tuplery   rz   r{   r,   r-   rt     s    z'ARRAY.result_processor.<locals>.processz^{(.*)}$rg   	list[str]c                   s     | d}t|S )Nr
   )matchgroup_split_enum_valuesrp   )patternr,   r-   handle_raw_string  s    z1ARRAY.result_processor.<locals>.handle_raw_stringc                   s&   | d kr| S t | tr  | n| S rB   )r;   rg   rz   )r   super_rpr,   r-   rt     s    
)r=   ru   result_processorre   recompile)r>   rf   r~   rt   r,   )r   rs   r   r>   r   r-   r     s     
zARRAY.result_processor)FNF)rQ   rR   rS   rT   r9   r:   r<   rc   r"   Zcomparator_factoryr   Zmemoized_propertyre   rv   r|   r   r,   r,   r,   r-   r<      s   J   3#r<   rg   r   )array_stringr)   c                 C  s   d| kr| r|  dS g S | dd}|dd}g }t d|}d}|D ]>}|dkr^| }qJ|rv||dd qJ|td	| qJ|S )
N",z\"z_$ESC_QUOTE$_z\\\z(")Fz([^\s,]+),?)splitreplacer   appendextendfindall)r   textresultZ	on_quotesZ	in_quotestokr,   r,   r-   r     s    r   )5
__future__r   r   typingr   r$   r   r   r   r   r   r	   r   r   r   r    r   r:   r   Zsqlr   Zsql.visitorsr   Zengine.interfacesr   Zsql._typingr   r   Zsql.elementsr   r   Zsql.expressionr   Zsql.operatorsr   Zsql.selectabler   Zsql.type_apir   r   r   r   r    Zutil.typingr!   r"   eqr/   ZExpressionClauseListr0   r<   r   r,   r,   r,   r-   <module>	   sR    # |