
    ,hZB                    ^   S SK Jr  S SKrS SKJr  S SKJr  S SKJr  S SKJr  S SKJ	r	  S SKJ
r
  S S	KJr  S
SKJr  S
SKJr  S
SKJr  SSKJr  SSKJr  SSKJr  SSKJr  SSKJr  \	(       aT  SSKJr  SSKJr  SSKJr  SSKJr  SSKJr  SSK J!r!  SSK"J#r#  SSK$J%r%  SSK&J'r'  SSK&J(r(  SSK&J)r)  SSK&J*r*  SS KJ+r+  SS!K,J-r-  \
" S"\S#9r.\R^                  4       S+S$ jjr\R^                  4       S+S% jjr0 " S& S'\Rb                  \.   5      r2 " S( S)\Rf                  \.   5      r3S,S* jr4g)-    )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)boundc                $    UR                  X5      $ )zbA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method.
See that method for details.

)anyotherarrexproperators      \/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/dialects/postgresql/array.pyr   r   1        ;;u''    c                $    UR                  X5      $ )zbA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method.
See that method for details.

)allr'   s      r+   Allr0   >   r,   r-   c                     ^  \ rS rSr% SrS rSrS\R                  4S\R                  4/r
S\S'   SS	.     SU 4S
 jjjr\SS j5       r  S         SS jjr S   SS jjrSrU =r$ )arrayK   a  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`


postgresqlclausestyper!   _traverse_internalsN)type_c               ~  > [         TU ]  " [        R                  /UQ70 UD6  Ub  UO9U R                  (       a  U R                  S   R
                  O[        R                  n[        U[        5      (       a6  [        UR                  UR                  b  UR                  S-   OSS9U l        g[        U5      U l        g)zConstruct 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   comma_opr5   r6   sqltypesNULLTYPE
isinstanceARRAY	item_typer;   )selfr5   r8   kw	main_type	__class__s        r+   r=   array.__init__   s     	++<g<<   )-a%%8;L;L 	 i''## !++7 ((1,DI i(DIr-   c                    U 4$ N rD   s    r+   _select_iterablearray._select_iterable   s	    wr-   c                    U(       d  U[         R                  L a#  [        R                  " S UUUU R                  SS9$ [        U Vs/ s H  nU R                  XSUS9PM     sn5      $ s  snf )NT)_compared_to_operatorr8   _compared_to_typeunique)_assume_scalarr8   )r   getitemr   r   r6   r2   _bind_param)rD   r*   objr8   rS   os         r+   rU   array._bind_param   s     X):)::++&."&))  
 !	 ! $$ D %  !	 s   A)c                    U[         R                  [         R                  [         R                  4;   a  [        R
                  " U 5      $ U $ rJ   )r   any_opall_oprT   r   r   )rD   againsts     r+   
self_grouparray.self_group   s;     y'')9)99;L;LMM&&t,,Kr-   )r6   )r5   zIterable[_T]r8   z!Optional[_TypeEngineArgument[_T]]rE   
typing_Any)returnr   )NF)
r*   r   rV   r_   r8   zOptional[TypeEngine[_T]]rS   boolr`   zBindParameter[_T]rJ   )r\   zOptional[OperatorType]r`   zUnion[Self, Grouping[_T]])__name__
__module____qualname____firstlineno____doc____visit_name__stringify_dialectr   dp_clauseelement_tupledp_typer7   __annotations__r=   propertyrM   rU   r]   __static_attributes____classcell__)rG   s   @r+   r2   r2   K   s    KZ N$ 
%<<=	"**+3/  48	!)!) 1	!)
 !) !)F   +/$  (	
  
8 15-	" r-   r2   c                      \ rS rSrSr   S       SS jjr " S S\R                  R                  \	   5      r\r
\R                  SS j5       r    SS jr    SS	 jr      SS
 jrSrg)rB      a	  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.

Nc                    [        U[        5      (       a  [        S5      e[        U[        5      (       a  U" 5       nXl        X l        X0l        X@l        g)au  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)rA   rB   
ValueErrorr6   rC   as_tupler;   zero_indexes)rD   rC   rs   r;   rt   s        r+   r=   ARRAY.__init__5  sO    N i''?  i&&!I" $(r-   c                  B    \ rS rSrSr      SS jrS	S jrS	S jrSrg)
ARRAY.Comparatorih  a  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`.

c                H    U R                  [        U[        R                  S9$ )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.
result_type)operater   r?   Boolean)rD   r(   kwargss      r+   containsARRAY.Comparator.containsr  s     <<%X=M=M<NNr-   c                H    U R                  [        U[        R                  S9$ )zlBoolean expression.  Test if elements are a proper subset of the
elements of the argument array expression.
ry   )r{   r   r?   r|   rD   r(   s     r+   contained_byARRAY.Comparator.contained_by}  s'     <<e1A1A    r-   c                H    U R                  [        U[        R                  S9$ )z]Boolean expression.  Test if array has elements in common with
an argument array expression.
ry   )r{   r   r?   r|   r   s     r+   overlapARRAY.Comparator.overlap  s     <<H<L<L<MMr-   rK   N)r(   r_   r}   r_   r`   ColumnElement[bool])r(   r_   r`   r   )	rb   rc   rd   re   rf   r~   r   r   rm   rK   r-   r+   
Comparatorrw   h  s3    			O#		O/9		O 		O		Nr-   r   c                    [        U R                  [        R                  5      =(       a    U R                  R                  $ rJ   )rA   rC   r?   Enumnative_enumrL   s    r+   _against_native_enumARRAY._against_native_enum  s-     t~~x}}5 +**	
r-   c                   ^ ^^ T R                   R                  U5      R                  U5      mTc  g SS jmSUU U4S jjnU$ )Nc                ,    SSR                  U 5       S3$ )NzARRAY[z, ])join)elementss    r+   to_str'ARRAY.literal_processor.<locals>.to_str  s    DIIh/022r-   c                D   > TR                  U TTR                  T5      nU$ rJ   )_apply_item_processorr;   )valueinner	item_procrD   r   s     r+   process(ARRAY.literal_processor.<locals>.process  s'    ..y$//6E Lr-   )r   zIterable[typing_Any]r`   str)r   Sequence[typing_Any]r`   r   )rC   dialect_implliteral_processor)rD   dialectr   r   r   s   `  @@r+   r   ARRAY.literal_processor  sH     NN//8JJ
	 	3	 	 r-   c                x   ^ ^ T R                   R                  U5      R                  U5      m    SUU 4S jjnU$ )Nc                R   > U c  U $ TR                  U TTR                  [        5      $ rJ   )r   r;   listr   r   rD   s    r+   r   %ARRAY.bind_processor.<locals>.process  s/     }119doot r-   )r   Optional[Sequence[typing_Any]]r`   zOptional[list[typing_Any]])rC   r   bind_processor)rD   r   r   r   s   `  @r+   r   ARRAY.bind_processor  sH     NN//8GG
		1	'	 	 r-   c                   ^ ^^^^ T R                   R                  U5      R                  X5      m    SUU 4S jjnT R                  (       a-  Um[        R
                  " S5      mSU4S jjm    SUU4S jjnU$ )Nc                   > U c  U $ TR                  U TTR                  TR                  (       a
  [        5      $ [        5      $ rJ   )r   r;   rs   tupler   r   s    r+   r   'ARRAY.result_processor.<locals>.process  sG     }11OO!]]E	  15	 r-   z^{(.*)}$c                Z   > TR                  U 5      R                  S5      n[        U5      $ )Nr   )matchgroup_split_enum_values)r   r   patterns     r+   handle_raw_string1ARRAY.result_processor.<locals>.handle_raw_string  s'    e,2215)%00r-   c                `   > U c  U $ T" [        U [        5      (       a  T" U 5      5      $ U 5      $ rJ   )rA   r   )r   r   super_rps    r+   r   r     sD     = L  !%-- &e,   r-   )r   r   r`   r   )r   r   r`   	list[str])rC   r   result_processorr   recompile)rD   r   coltyper   r   r   r   r   s   `   @@@@r+   r   ARRAY.result_processor  s     NN//8II
		'	+	 	 $$Hjj-G1+/  r-   )rs   r;   rC   rt   )FNF)rC   z_TypeEngineArgument[_T]rs   ra   r;   zOptional[int]rt   ra   )r`   ra   )r   r   r`   z#Optional[_LiteralProcessorType[_T]])r   r   r`   z2Optional[_BindProcessorType[Sequence[typing_Any]]])r   r   r   objectr`   z*_ResultProcessorType[Sequence[typing_Any]])rb   rc   rd   re   rf   r=   r?   rB   r   r#   comparator_factoryr   memoized_propertyr   r   r   r   rm   rK   r-   r+   rB   rB      s    ET $("1)*1) 1) "	1)
 1)f!NX^^..r2 !NF $	
 
	,(	;&**)/*	3*r-   rB   c                   SU ;  a  U (       a  U R                  S5      $ / $ U R                  SS5      nUR                  SS5      n/ n[        R                   " SU5      nSnU Hb  nUS:X  a	  U(       + nM  U(       a#  UR                  UR                  SS5      5        M<  UR	                  [        R
                  " S	U5      5        Md     U$ )
N",z\"z_$ESC_QUOTE$_z\\\z(")Fz([^\s,]+),?)splitreplacer   appendextendfindall)array_stringtextresult	on_quotes	in_quotestoks         r+   r   r     s    
,*6|!!#&>B> 7D<<t$DF&II#:%IMM#++os;<MM"**^S9:  Mr-   )r(   r_   r)   z_ColumnExpressionArgument[_T]r*   r   r`   r   )r   r   r`   r   )5
__future__r   r   typingr   r_   r   r   r   r   r	   r
   r   r   r   r    r   r?   r   sqlr   sql.visitorsr   engine.interfacesr   sql._typingr   r   sql.elementsr   r   sql.expressionr   sql.operatorsr   sql.selectabler   sql.type_apir   r   r   r    r!   util.typingr"   r#   eqr0   ExpressionClauseListr2   rB   r   rK   r-   r+   <module>r      s   # 	 $        #   !    -,82-(/-1254*6# T$ '\\
(
(*
( 
( 	
(  '\\
(
(*
( 
( 	
(_J++B/ _DxHNN2 xvr-   