o
    [h/                     @   s   d dl Z ddlmZ ddlmZ ddlmZ ddlmZ ejfddZ	ejfd	d
Z
G dd dejZejdddZejdddZejdddZG dd dejZdS )    N   )types)util)
expression)	operatorsc                 C      | | |S )zA synonym for the :meth:`.ARRAY.Comparator.any` method.

    This method is legacy and is here for backwards-compatibility.

    .. seealso::

        :func:`_expression.any_`

    )anyotherZarrexproperator r   /home/ubuntu/experiments/live_experiments/Pythonexperiments/Otree/venv/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/array.pyAny      r   c                 C   r   )zA synonym for the :meth:`.ARRAY.Comparator.all` method.

    This method is legacy and is here for backwards-compatibility.

    .. seealso::

        :func:`_expression.all_`

    )allr	   r   r   r   All   r   r   c                       s8   e Zd ZdZd Z fddZd
ddZ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::

        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 ``type_`` keyword argument is passed::

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

    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::

        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`

    c                    s`   t t| j|i | t| jtr(t| jj| jjd ur!| jjd ndd| _d S t| j| _d S )N      )
dimensions)superr   __init__
isinstancetypeARRAY	item_typer   )selfZclauseskw	__class__r   r   r   c   s   zarray.__init__FNc                    s@   |s t ju rtjd | jddS t fdd|D S )NT)Z_compared_to_operatortype_Z_compared_to_typeuniquec                    s   g | ]}j  |d dqS )T)_assume_scalarr    )_bind_param).0or   r   r    r   r   
<listcomp>|   s    z%array._bind_param.<locals>.<listcomp>)r   getitemr   ZBindParameterr   r   )r   r   objr"   r    r   r&   r   r#   o   s   
zarray._bind_paramc                 C   s"   |t jt jt jfv rt| S | S N)r   Zany_opZall_opr(   r   ZGrouping)r   Zagainstr   r   r   
self_group   s   
zarray.self_group)FNr*   )	__name__
__module____qualname____doc__Z__visit_name__r   r#   r+   __classcell__r   r   r   r   r   ,   s    3
r   z@>   )
precedencez<@z&&c                   @   s   e Zd ZdZG dd dejjZeZ	dddZe	dd	 Z
e	d
d Zdd Zdd Zejdd Zejdd Zdd Zdd Zdd ZdS )r   a  PostgreSQL ARRAY type.

    .. versionchanged:: 1.1 The :class:`_postgresql.ARRAY` type is now
       a subclass of the core :class:`_types.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])

    The :class:`_postgresql.ARRAY` type may not be supported on all
    PostgreSQL DBAPIs; it is currently known to work on psycopg2 only.

    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`.

    .. seealso::

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

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

    c                   @   s(   e Zd ZdZdd Zdd Z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`.

        c                 K      | j t|tjdS )zBoolean expression.  Test if elements are a superset of the
            elements of the argument array expression.
            Zresult_type)operateCONTAINSsqltypesBoolean)r   r
   kwargsr   r   r   contains      zARRAY.Comparator.containsc                 C   r3   )zBoolean expression.  Test if elements are a proper subset of the
            elements of the argument array expression.
            r4   )r5   CONTAINED_BYr7   r8   r   r
   r   r   r   contained_by   s   zARRAY.Comparator.contained_byc                 C   r3   )zuBoolean expression.  Test if array has elements in common with
            an argument array expression.
            r4   )r5   OVERLAPr7   r8   r=   r   r   r   overlap   r;   zARRAY.Comparator.overlapN)r,   r-   r.   r/   r:   r>   r@   r   r   r   r   
Comparator   s
    	rA   FNc                 C   s>   t |tr	tdt |tr| }|| _|| _|| _|| _dS )aP  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.

         .. versionadded:: 0.9.5


        zUDo not nest ARRAY types; ARRAY(basetype) handles multi-dimensional arrays of basetypeN)r   r   
ValueErrorr   r   as_tupler   zero_indexes)r   r   rC   r   rD   r   r   r   r      s   
&

zARRAY.__init__c                 C   s   | j S r*   )rC   r   r   r   r   hashable  s   zARRAY.hashablec                 C   s   t S r*   )listrE   r   r   r   python_type  s   zARRAY.python_typec                 C   s   ||kS r*   r   )r   xyr   r   r   compare_values  s   zARRAY.compare_valuesc                    st   d u rt |}dksd u r,|rt|d t tfs,r( fdd|D S  |S   fdd|D S )Nr   r   c                 3   s    | ]} |V  qd S r*   r   r$   rI   )itemprocr   r   	<genexpr>.  s    z$ARRAY._proc_array.<locals>.<genexpr>c                 3   s0    | ]} |d urd nd  V  qd S )Nr   )_proc_arrayrL   
collectiondimrM   r   r   r   rN   2  s    
)rG   r   tuple)r   ZarrrM   rR   rQ   r   rP   r   rO     s   	zARRAY._proc_arrayc                 C   s   | j p	t| jtjS r*   )_against_native_enumr   r   r7   JSONrE   r   r   r   _require_cast<  s   zARRAY._require_castc                 C   s   t | jtjo
| jjS r*   )r   r   r7   EnumZnative_enumrE   r   r   r   rT   B  s   zARRAY._against_native_enumc                 C   s   | j r	t|| S |S r*   )rV   r   cast)r   Z	bindvaluer   r   r   bind_expressionI  s   zARRAY.bind_expressionc                    s$   j ||  fdd}|S )Nc                    s   | d u r| S  |  jtS r*   )rO   r   rG   value	item_procr   r   r   processT  s
   
z%ARRAY.bind_processor.<locals>.process)r   dialect_implbind_processor)r   dialectr^   r   r\   r   r`   O  s
   zARRAY.bind_processorc                    sF   j |||fdd}jr!|dd   fdd}|S )Nc                    s*   | d u r| S  |  jjrtS tS r*   )rO   r   rC   rS   rG   rZ   r\   r   r   r^   c  s   z'ARRAY.result_processor.<locals>.processc                 S   s$   t d| d}|r|dS g S )Nz^{(.*)}$r   ,)rematchgroupsplit)r[   innerr   r   r   handle_raw_stringq  s   z1ARRAY.result_processor.<locals>.handle_raw_stringc                    s*   | d u r| S t | tjr | S | S r*   )r   r   string_typesrZ   )rh   super_rpr   r   r^   u  s   
)r   r_   result_processorrT   )r   ra   Zcoltyper^   r   )rh   r]   r   rj   r   rk   ^  s   zARRAY.result_processor)FNF)r,   r-   r.   r/   r7   r   rA   Zcomparator_factoryr   propertyrF   rH   rK   rO   r   Zmemoized_propertyrV   rT   rY   r`   rk   r   r   r   r   r      s&    -
2



r   )rc    r   r7   r   sqlr   r   eqr   r   Tupler   Z	custom_opr6   r<   r?   r   r   r   r   r   <module>   s   _