Ë
    ðmxiC  ã                  ód  — 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	rTd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¬#«      Z. e
d$e¬#«      Z/ej`                  f	 	 	 	 	 	 	 d,d%„Zej`                  f	 	 	 	 	 	 	 d,d&„Z1 G d'„ d(ejd                  e.   «      Z3 G d)„ d*ejh                  e.   «      Z4d-d+„Z5y).é    )Ú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Ú_CTc                ó&   — |j                  | |«      S )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method.
    See that method for details.

    )Úany©ÚotherÚarrexprÚoperators      ú[/home/htdocs/ttos/venv/lib/python3.12/site-packages/sqlalchemy/dialects/postgresql/array.pyr   r   2   ó   € ð �;‰;�u˜hÓ'Ð'ó    c                ó&   — |j                  | |«      S )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method.
    See that method for details.

    )Úallr(   s      r,   ÚAllr1   ?   r-   r.   c                  óÄ   ‡ — 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ˆ fd	„Zedd
„«       Z	 	 d	 	 	 	 	 	 	 	 	 dd„Z	 d	 	 	 dd„Zˆ x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`

    Ú
postgresqlÚclausesÚtyper!   Ú_traverse_internalsN)Útype_c               ój  •— t        ‰| �  t        j                  g|¢­i |¤Ž |�|n4| j                  r| j                  d   j
                  nt        j                  }t        |t        «      r8t        |j                  |j                  �|j                  dz   nd¬«      | _        yt        |«      | _        y)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   Úcomma_opr5   r6   ÚsqltypesÚNULLTYPEÚ
isinstanceÚARRAYÚ	item_typer;   )Úselfr5   r8   ÚkwÚ	main_typeÚ	__class__s        €r,   r=   zarray.__init__£   s£   ø€ ô 	‰Ñœ×+Ñ+Ð<¨gÒ<¸Ò<ð Ð ñ à)-¯ª�—‘˜a‘×%Ò%¼8×;LÑ;Lð 	ô �i¤Ô'ÜØ×#Ñ#ð !×+Ñ+Ð7ð ×(Ñ(¨1Ò,àôˆD�Iô ˜iÓ(ˆD�Ir.   c                ó   — | fS ©N© ©rD   s    r,   Ú_select_iterablezarray._select_iterableÆ   s	   € àˆwˆr.   c                óÖ   — |s|t         j                  u r%t        j                  d |||| j                  d¬«      S t        |D �cg c]  }| j                  ||d|¬«      ‘Œ c}«      S c c}w )NT)Ú_compared_to_operatorr8   Ú_compared_to_typeÚunique)Ú_assume_scalarr8   )r   Úgetitemr   r   r6   r3   Ú_bind_param)rD   r+   Úobjr8   rQ   Úos         r,   rS   zarray._bind_paramÊ   s„   € ñ ˜X¬×):Ñ):Ñ:Ü×+Ñ+ØØØ&.ØØ"&§)¡)Øôð ô ð
 !ö	ð ð ×$Ñ$Ø  !°DÀð %õ òóð ùòs   ÁA&c                ó’   — |t         j                  t         j                  t         j                  fv rt	        j
                  | «      S | S rI   )r   Úany_opÚall_oprR   r   r   )rD   Úagainsts     r,   Ú
self_groupzarray.self_groupå   s;   € ð ”y×'Ñ'¬×)9Ñ)9¼9×;LÑ;LÐMÑMÜ×&Ñ& tÓ,Ð,àˆKr.   )r5   zIterable[_T]r8   z!Optional[_TypeEngineArgument[_T]]rE   Ú
typing_Any)Úreturnr   )NF)
r+   r   rT   r[   r8   zOptional[TypeEngine[_T]]rQ   Úboolr\   zBindParameter[_T]rI   )rY   zOptional[OperatorType]r\   zUnion[Self, Grouping[_T]])Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__visit_name__Ústringify_dialectr   Údp_clauseelement_tupleÚdp_typer7   Ú__annotations__r=   ÚpropertyrL   rS   rZ   Ú__classcell__)rG   s   @r,   r3   r3   L   sÙ   ø… ñKðZ €Nà$Ðð 
Ð%×<Ñ<Ð=Ø	Ð"×*Ñ*Ð+ð3ÐÐ/ó ð 48ñ	!)àð!)ð 1ð	!)ð
 õ!)ðF òó ðð +/Ø$ðàðð ðð (ð	ð
 ðð 
óð8 15ðØ-ðà	"÷r.   r3   c                  óÐ   — e Zd ZdZ	 	 	 d
	 	 	 	 	 	 	 dd„Z G d„ dej                  j                  e   «      ZeZ	e
j                  dd„«       Z	 	 	 	 dd„Z	 	 	 	 dd„Z	 	 	 	 	 	 dd	„Zy)rB   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.

    Nc                ó    — t        |t        «      rt        d«      ‚t        |t        «      r |«       }|| _        || _        || _        || _        y)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)rA   rB   Ú
ValueErrorr6   rC   Úas_tupler;   Úzero_indexes)rD   rC   rl   r;   rm   s        r,   r=   zARRAY.__init__6  sQ   € ôN �i¤Ô'Üð?óð ô �i¤Ô&Ù!›ˆIØ"ˆŒØ ˆŒØ$ˆŒØ(ˆÕr.   c                  ó4   — e Zd ZdZ	 	 	 	 	 	 dd„Zdd„Zdd„Zy)ú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`.

        c                óN   — | j                  t        |t        j                  ¬«      S )zåBoolean 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,   ÚcontainszARRAY.Comparator.containss  s   € ð —<‘<¤¨%¼X×=MÑ=M�<ÓNÐNr.   c                óN   — | j                  t        |t        j                  ¬«      S )z„Boolean expression.  Test if elements are a proper subset of the
            elements of the argument array expression.
            rq   )rs   r   r?   rt   ©rD   r)   s     r,   Úcontained_byzARRAY.Comparator.contained_by~  s'   € ð —<‘<Ü˜e´×1AÑ1Að  ó ð r.   c                óN   — | j                  t        |t        j                  ¬«      S )zuBoolean expression.  Test if array has elements in common with
            an argument array expression.
            rq   )rs   r   r?   rt   rx   s     r,   ÚoverlapzARRAY.Comparator.overlap†  s   € ð —<‘<¤¨¼H×<LÑ<L�<ÓMÐMr.   N)r)   r[   ru   r[   r\   úColumnElement[bool])r)   r[   r\   r|   )r^   r_   r`   ra   rv   ry   r{   rJ   r.   r,   Ú
Comparatorro   i  s3   „ ñ	ð		OØ#ð		OØ/9ð		Oà ó		Oó	ô	Nr.   r}   c                óz   — t        | j                  t        j                  «      xr | j                  j                  S rI   )rA   rC   r?   ÚEnumÚnative_enumrK   s    r,   Ú_against_native_enumzARRAY._against_native_enumŽ  s-   € ô �t—~‘~¤x§}¡}Ó5ò +Ø—‘×*Ñ*ð	
r.   c                ó~   ‡ ‡‡— ‰ j                   j                  |«      j                  |«      Š‰€y dd„Šdˆˆ ˆfd„}|S )Nc                ó,   — ddj                  | «      › d�S )NzARRAY[z, ú])Újoin)Úelementss    r,   Úto_strz'ARRAY.literal_processor.<locals>.to_strž  s   € Ø˜DŸI™I hÓ/Ð0°Ð2Ð2r.   c                óD   •— ‰j                  | ‰‰j                  ‰«      }|S rI   )Ú_apply_item_processorr;   )ÚvalueÚinnerÚ	item_procrD   r‡   s     €€€r,   Úprocessz(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‘   zARRAY.literal_processor•  sC   ú€ ð —N‘N×/Ñ/°Ó8×JÑJØó
ˆ	ð ÐØó	3÷	ð ˆr.   c                ót   ‡ ‡— ‰ j                   j                  |«      j                  |«      Š	 	 	 	 dˆˆ fd„}|S )Nc                óP   •— | €| S ‰j                  | ‰‰j                  t        «      S rI   )r‰   r;   Úlist©rŠ   rŒ   rD   s    €€r,   r�   z%ARRAY.bind_processor.<locals>.process°  s/   ø€ ð ˆ}Ø�à×1Ñ1Ø˜9 d§o¡o´tóð r.   )rŠ   úOptional[Sequence[typing_Any]]r\   zOptional[list[typing_Any]])rC   r�   Úbind_processor)rD   r’   r�   rŒ   s   `  @r,   r˜   zARRAY.bind_processor©  sC   ù€ ð —N‘N×/Ñ/°Ó8×GÑGØó
ˆ	ð	Ø1ð	à'ö	ð ˆr.   c                óä   ‡ ‡‡‡‡— ‰ j                   j                  |«      j                  ||«      Š	 	 	 	 dˆˆ fd„}‰ j                  r(|Št	        j
                  d«      Šdˆfd„Š	 	 	 	 dˆˆfd„}|S )Nc                ó|   •— | €| S ‰j                  | ‰‰j                  ‰j                  r
t        «      S t        «      S rI   )r‰   r;   rl   Útupler•   r–   s    €€r,   r�   z'ARRAY.result_processor.<locals>.processÃ  sG   ø€ ð ˆ}Ø�à×1Ñ1ØØØ—O‘OØ!Ÿ]š]”Eó	ð ô 15ó	ð r.   z^{(.*)}$c                óZ   •— ‰j                  | «      j                  d«      }t        |«      S )Nr   )ÚmatchÚgroupÚ_split_enum_values)rŠ   r‹   Úpatterns     €r,   Úhandle_raw_stringz1ARRAY.result_processor.<locals>.handle_raw_stringÔ  s'   ø€ ØŸ™ eÓ,×2Ñ2°1Ó5�Ü)¨%Ó0Ð0r.   c                óT   •— | €| S  ‰t        | t        «      r ‰| «      «      S | «      S rI   )rA   rŽ   )rŠ   r¡   Úsuper_rps    €€r,   r�   z'ARRAY.result_processor.<locals>.processØ  sA   ø€ ð �=Ø �Lñ  ä! %¬Ô-ñ & eÓ,óð ð óð r.   )rŠ   r�   r\   r—   )rŠ   rŽ   r\   úSequence[Optional[str]])rC   r�   Úresult_processorr�   ÚreÚcompile)rD   r’   Úcoltyper�   r¡   rŒ   r    r£   s   `   @@@@r,   r¥   zARRAY.result_processor¼  s}   ü€ ð —N‘N×/Ñ/°Ó8×IÑIØ�Wó
ˆ	ð	Ø'ð	à+ö	ð ×$Ò$ØˆHÜ—j‘j Ó-ˆGõ1ðØ+ðà/öð ˆr.   )FNF)rC   z_TypeEngineArgument[_T]rl   r]   r;   zOptional[int]rm   r]   )r\   r]   )r’   r   r\   z#Optional[_LiteralProcessorType[_T]])r’   r   r\   z2Optional[_BindProcessorType[Sequence[typing_Any]]])r’   r   r¨   Úobjectr\   z*_ResultProcessorType[Sequence[typing_Any]])r^   r_   r`   ra   r=   r?   rB   r}   r%   Úcomparator_factoryr   Úmemoized_propertyr�   r‘   r˜   r¥   rJ   r.   r,   rB   rB   î   sÅ   „ ñEðT Ø$(Ø"ð1)à*ð1)ð ð1)ð "ð	1)ð
 ó1)ôf!N�X—^‘^×.Ñ.¨sÑ3ô !NðF $Ðà	×Ñò
ó ð
ðØðà	,óð(Øðà	;óð&*Øð*Ø)/ð*à	3ô*r.   rB   c                óÎ  — d| vr*| r| j                  d«      ng D �cg c]  }|dk7  r|nd ‘Œ c}S | j                  dd«      }|j                  dd«      }g }t        j                   d|«      }d	}|D ]i  }|dk(  r| }Œ|r"|j                  |j                  dd«      «       Œ0|j	                  t        j
                  d
|«      D �cg c]  }|dk7  r|nd ‘Œ c}«       Œk |S c c}w c c}w )Nú"ú,ÚNULLz\"z_$ESC_QUOTE$_z\\ú\z(")Fz([^\s,]+),?)ÚsplitÚreplacer¦   ÚappendÚextendÚfindall)Úarray_stringÚrÚtextÚresultÚ	on_quotesÚ	in_quotesÚtoks          r,   rŸ   rŸ   é  s  € Ø
�,Ññ 2>�l×(Ñ(¨Ô-À2ö
àð �f’‰A $Ñ&ò
ð 	
ð ×Ñ  Ó7€DØ�<‰<˜˜tÓ$€DØ€FÜ—‘˜ Ó&€IØ€IØò ˆØ�#Š:Ø%˜‰IÙØ�M‰M˜#Ÿ+™+ o°sÓ;Õ<ð �M‰Mô  ŸZ™Z¨¸Ó<öàð ˜fš‘A¨$Ñ.òõðð €Mùò7
ùò,s   œCÃC"
)r)   r[   r*   z_ColumnExpressionArgument[_T]r+   r   r\   r|   )r¶   rŽ   r\   r¤   )6Ú
__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#   r%   Úeqr1   ÚExpressionClauseListr3   rB   rŸ   rJ   r.   r,   ú<module>rÌ      s  ðõ #ã 	Ý $Ý Ý Ý Ý  Ý Ý å #Ý Ý Ý !Ý Ý Ý Ý -áÝ,Ý8Ý2Ý-Ý(Ý/Ý-Ý1Ý2Ý5Ý4Ý*Ý6Ý#ñ ˆT˜Ô$€Ùˆe˜:Ô&€ð 'Ÿ\™\ð
(Øð
(à*ð
(ð ð
(ð ó	
(ð  'Ÿ\™\ð
(Øð
(à*ð
(ð ð
(ð ó	
(ô_ˆJ×+Ñ+¨BÑ/ô _ôDxˆH�N‰N˜2Ñô xôvr.   