
    +h!                         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  G d dej                        Z G d de      Zd Zy)   )ARRAY   )util)	coercions)elements)
expression)	functions)roles)schema)ColumnCollectionConstraint)InternalTraversalc                       e Zd ZdZd ZdZdej                  fdej                  fdej                  fgZ	d Z
ddZd	 Zej                  fd
Zed        Zy)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::

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

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

    .. versionadded:: 1.1

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

    .. seealso::

        :class:`_functions.array_agg`

    
postgresqltargettypeorder_byc                 v   t        j                  t        j                  |      | _        | j                  j
                  | _        t        |      }|dk(  rt        d      |dk(  r-t        j                  t        j                  |d         | _        y t        j                  |dt        j                  i| _        y )N    z)at least one ORDER BY element is requiredr   _literal_as_text_role)r   expectr
   ExpressionElementRoler   r   len	TypeErrorr   r   
ClauseList)selfr   r   _lobs       U/var/www/html/venv/lib/python3.12/site-packages/sqlalchemy/dialects/postgresql/ext.py__init__zaggregate_order_by.__init__@   s    &&u'B'BFKKK$$	8}19GHHQY%,,++Xa[DM %//161L1LDM    Nc                     | S N )r   againsts     r   
self_groupzaggregate_order_by.self_groupP   s    r    c                 2    | j                   | j                  fS r"   r   r   )r   kwargss     r   get_childrenzaggregate_order_by.get_childrenS   s    {{DMM))r    c                 d     || j                   fi || _          || j                  fi || _        y r"   r'   )r   clonekws      r   _copy_internalsz"aggregate_order_by._copy_internalsV   s,    DKK.2.dmm2r2r    c                 \    | j                   j                  | j                  j                  z   S r"   )r   _from_objectsr   )r   s    r   r/   z aggregate_order_by._from_objectsZ   s!    {{((4==+F+FFFr    r"   )__name__
__module____qualname____doc____visit_name__stringify_dialectr   dp_clauseelementdp_type_traverse_internalsr   r%   r)   r   _cloner-   propertyr/   r#   r    r   r   r      s}     D *N$	$556	"**+	&778 * %-OO 3 G Gr    r   c                   n     e Zd ZdZdZdZdZdZ ej                  ddd      d	        Z
 fd
ZddZ xZS )ExcludeConstraintzA 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

    exclude_constraintNFr   wherez:class:`.ExcludeConstraint`z$:paramref:`.ExcludeConstraint.where`c                    g }g }i | _         t        | \  }}t        t        j                  t        j
                  |      |      D ]R  \  \  }}}	}
}|
|j                  |
       ||j                  n|	}||| j                   |<   |j                  |||f       T || _        t        j                  | g||j                  d      |j                  d      |j                  d      d |j                  dd      | _        |j                  d      }|)t        j                  t        j                  |      | _        |j                  d	i       | _        y)
a2  
        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'}
                )
            )

        :param \*elements:

          A sequence of two tuples of the form ``(column, operator)`` where
          "column" is a SQL expression element or a raw SQL string, most
          typically a :class:`_schema.Column` object,
          and "operator" is a string
          containing the operator to use.   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.

        :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 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)r@   rA   rB   usinggistr>   ops)	operatorszipr    expect_col_expression_collectionr
   DDLConstraintColumnRoleappendr@   _render_exprsr   r   getrC   r   StatementOptionRoler>   rE   )r   r   r,   columnsrender_exprsexpressionsrF   exprcolumnstrnameadd_elementoperatorr@   r>   s                 r   r   zExcludeConstraint.__init__p   sQ   n !$hY>A66--{ 	?
 	8:0T67K( &{+"("46;;'D'/t$tX 67	8" *"++	
	
 vvl+ff[)	
 VVGV,
w"))%*C*CUKDJ66%$r    c           
         t         t        |   |       t        j                  | j
                  | j                        D cg c]*  \  \  }}}}t        |t        j                        r|n|||f, c}}}}| _        y c c}}}}w r"   )
superr<   _set_parentr   zip_longestrK   rN   
isinstancer   ClauseElement)r   tabler,   rQ   r@   rU   colexpr	__class__s          r   rX   zExcludeConstraint._set_parent   s}    259 483C3C""DLL4	
 	
 0&tX	 #4)?)?@g	
 	
s   /A?
c           	         | j                   D cg c]<  }t        j                  || j                  |      | j                  |j
                     f> }} | j                  || j
                  | j                  | j                  | j                  | j                  d}|j                  j                  | j                         |S c c}w )N)r@   rA   rB   r>   rC   )rN   r   _copy_expressionparentrF   r@   r^   rA   rB   r>   rC   dispatch_update)r   target_tabler,   rQ   r   cs         r   _copyzExcludeConstraint._copy   s     

  ''dkk<Htyy)
 
 DNNnn****
 	


4==)!
s   ACr"   )r0   r1   r2   r3   r4   r>   inherit_cachecreate_drop_stringify_dialectr   _document_text_coercionr   rX   rf   __classcell__)r^   s   @r   r<   r<   _   sT     *NEM$0!%X%%%.
w%
w%r
r    r<   c                  R    t         |d<   t        j                  j                  | i |S )zPostgreSQL-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.

    .. versionadded:: 1.1

    _default_array_type)r   r	   func	array_agg)argr,   s     r   rn   rn     s)     !&B>>##S/B//r    N)arrayr    r   sqlr   r   r   r	   r
   r   
sql.schemar   sql.visitorsr   ColumnElementr   r<   rn   r#   r    r   <module>rv      sQ            4 -HG11 HGVn2 nb
0r    