rjLddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z dd lm Z dd lm Z d d l m Z d d lmZddl mZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZe r0ddl m!Z!ddl m"Z"ddl#m$Z$ddl#m%Z%ddl&m'Z'ddl(m)Z)dd lm*Z*dd!lm+Z+e d"e#Z,Gd$d%ejJe,Z-Gd&d'eZ.d(Z/Gd)d*ej`e,Z1Gd+d,e1Z2Gd-d.e1Z3Gd/d0e1Z4Gd1d2e1Z5Gd3d4e1Z6Gd5d6e1Z7d;d8Z8Gd9d7eejHZ9y:)<) annotations)Any)Iterable)List)Optional)overload)Sequence)Tuple) TYPE_CHECKING)TypeVar)types)ARRAY)exc) coercions)elements) expression) functions)roles)schema)SyntaxExtension)ColumnCollectionConstraint)TEXT)InternalTraversal)_ColumnExpressionArgument)_DDLColumnArgument) ClauseElement) ColumnElement) OperatorType) FromClause)_CloneCallableType)_TraverseInternalsType_T)boundceZdZUdZdZdZdejfdejfdejfgZ de d<e ddZ e dd Z dd Z d dd Z dd Zej f ddZeddZy )aggregate_order_byaRepresent 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: .. sourcecode:: sql SELECT array_agg(a ORDER BY b DESC) FROM table; .. legacy:: An improved dialect-agnostic form of this function is now available in Core by calling the :meth:`_functions.Function.aggregate_order_by` method on any function defined by the backend as an aggregate function. .. seealso:: :func:`_sql.aggregate_order_by` - Core level function :class:`_functions.array_agg` postgresqltargettypeorder_byr#_traverse_internalscyNselfr)r+s m/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/sqlalchemy/dialects/postgresql/ext.py__init__zaggregate_order_by.__init__U  cyr.r/r0s r2r3zaggregate_order_by.__init__\r4r5cztjtj||_|jj |_t |}||dk(r td|dk(r-tjtj|d|_ytj|dtji|_y)Nrz)at least one ORDER BY element is requiredr _literal_as_text_role) rexpectrExpressionElementRoler)r*len TypeErrorr+r ClauseList)r1r)r+_lobs r2r3zaggregate_order_by.__init__cs &/%5%5  ' '&  KK$$ 8} 19GH H QY%,,++Xa[DM%//161L1LDMr5Nc|Sr.r/)r1againsts r2 self_groupzaggregate_order_by.self_groupzs  r5c 2|j|jfSr.r)r+)r1kwargss r2 get_childrenzaggregate_order_by.get_childrens{{DMM))r5c d||jfi||_||jfi||_yr.rC)r1clonekws r2_copy_internalsz"aggregate_order_by._copy_internalss.DKK.2. dmm2r2 r5c\|jj|jjzSr.)r) _from_objectsr+)r1s r2rKz aggregate_order_by._from_objectss!{{((4==+F+FFFr5)r)zColumnElement[_T]r+_ColumnExpressionArgument[Any])r)z_ColumnExpressionArgument[_T]r+rLr.)r@zOptional[OperatorType]returnr)rDrrMzIterable[ClauseElement])rGr"rHrrMNone)rMzList[FromClause])__name__ __module__ __qualname____doc____visit_name__stringify_dialectrdp_clauseelementdp_typer,__annotations__rr3rArEr_clonerIpropertyrKr/r5r2r'r'/s8*N$ $556 "**+ &7783/  ! 2   - 2  -2015-  *+3//3'3AD3 3 GGr5r'c|eZdZdZdZdZdZdZejddd d d Z fd Z d d Z xZ 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|\}}ttjtj ||D]R\\}}} } } | |j | | |jn| } | | |j| <|j || | fT||_tj|g||jd|jd|jd|jdd|jdd|_ |jd } | )tjtj| |_|jd i|_y) ap 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"}, ) ) The exclude constraint defined in this example requires the ``btree_gist`` extension, that can be created using the command ``CREATE EXTENSION btree_gist;``. :param \*elements: A sequence of two tuples of the form ``(column, operator)`` where "column" is either a :class:`_schema.Column` object, or a SQL expression element (e.g. ``func.int8range(table.from, table.to)``) or the name of a column as string, and "operator" is a string containing the operator to use (e.g. `"&&"` or `"="`). 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. The ``column`` may also be a string SQL expression when passed as :func:`_expression.literal_column` or :func:`_expression.text` :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 when issuing DDL for this constraint. :param info: Optional data dictionary which will be populated into the :attr:`.SchemaItem.info` attribute of this object. .. versionadded:: 2.0.50 :param using: Optional string. If set, emit USING when issuing DDL for this constraint. Defaults to 'gist'. :param where: Optional SQL expression construct or literal SQL string. If set, emit WHERE 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 ` parameter specified to the :class:`_schema.Index` construct. .. seealso:: :ref:`postgresql_operator_classes` - general description of how PostgreSQL operator classes are specified. Nname deferrable initiallyinfo)r_r`rarbusinggistr]ops) operatorszipr expect_col_expression_collectionrDDLConstraintColumnRoleappendr_ _render_exprsrr3getrcr9StatementOptionRoler]re)r1rrHcolumns render_exprs expressionsrfexprcolumnstrname add_elementoperatorr_r]s r2r3zExcludeConstraint.__init__s\H !$h Y>A  6 6--{   ?  8 : 0T67K( &{+"("46;;'D'/t$   tX 6 7 8"*"++   vvl+ff[)  VVGV, w  "))%*C*CUKDJ66%$r5c t|||jDcgc]*\}}}t|ts|n|j |||f,c}}}|_ycc}}}wr.)super _set_parentrk isinstancestrc)r1tablerHrqr_ru __class__s r2rxzExcludeConstraint._set_parent*sc E"*.););   %dH 'tS1uwwt}   s/Ac r|jDcgc])\}}}tj||j||f+}}}}|j||j |j |j|j|jd}|jj|j|Scc}}}w)N)r_r`rar]rc) rkr_copy_expressionparentr}r_r`rar]rcdispatch_update)r1 target_tablerHrq_rurr{s r2_copyzExcludeConstraint._copy6s &*%7%7   "a''dkk<H    DNN nn****   4==)! s.B2)rzTuple[_DDLColumnArgument, str]rHrrMrNr.)rOrPrQrRrSr] inherit_cachecreate_drop_stringify_dialectr_document_text_coercionr3rxr __classcell__r}s@r2r[r[so*N EM$0!%X%%%. E%7E%?BE% E%  E%N  r5r[cRt|d<tjj|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. _default_array_type)rrfunc array_agg)argrHs r2rrJs)!&B >> # #S /B //r5c"eZdZdZfdZxZS) _regconfig_fnTc t|}t|dkDrTtjtj |j dt|dd|tj}|g}ng}|Dcgc]4}tjtj |t|dd|6}}t|,||zi|ycc}w)Nr rr_)r_apply_propagate_attrstype_r_r) listr;rr9rr:popgetattrr REGCONFIGrwr3)r1argsrD initial_argr{ addtl_argsr}s r2r3z_regconfig_fn.__init__XsDz t9q=#**++ T640&*oo K'-KK    ++T640&*     ;3?? s59C)rOrPrQrr3rrs@r2rrUsM@@r5rc,eZdZdZdZej Zy) to_tsvectoraThe PostgreSQL ``to_tsvector`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_postgresql.TSVECTOR`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.to_tsvector` will be used automatically when invoking ``sqlalchemy.func.to_tsvector()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 TN)rOrPrQrRrrTSVECTORr*r/r5r2rrrs"M >>Dr5rc,eZdZdZdZej Zy) to_tsqueryaThe PostgreSQL ``to_tsquery`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_postgresql.TSQUERY`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.to_tsquery` will be used automatically when invoking ``sqlalchemy.func.to_tsquery()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 TNrOrPrQrRrrTSQUERYr*r/r5r2rr"M ==Dr5rc,eZdZdZdZej Zy)plainto_tsqueryaThe PostgreSQL ``plainto_tsquery`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_postgresql.TSQUERY`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.plainto_tsquery` will be used automatically when invoking ``sqlalchemy.func.plainto_tsquery()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 TNrr/r5r2rrrr5rc,eZdZdZdZej Zy)phraseto_tsqueryaThe PostgreSQL ``phraseto_tsquery`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_postgresql.TSQUERY`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.phraseto_tsquery` will be used automatically when invoking ``sqlalchemy.func.phraseto_tsquery()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 TNrr/r5r2rrrr5rc,eZdZdZdZej Zy)websearch_to_tsqueryaThe PostgreSQL ``websearch_to_tsquery`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_postgresql.TSQUERY`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.websearch_to_tsquery` will be used automatically when invoking ``sqlalchemy.func.websearch_to_tsquery()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 TNrr/r5r2rrrr5rc*eZdZdZdZeZfdZxZS) ts_headlineaThe PostgreSQL ``ts_headline`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_types.TEXT`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.ts_headline` will be used automatically when invoking ``sqlalchemy.func.ts_headline()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 Tc 0t|}t|dkrd}nKt|dtjr,|dj j tjurd}nd}|rTtjtj|jd|t|ddtj}|g}ng}|Dcgc]4}tjtj|t|dd|6}}t!|D||zi|ycc}w) NFr Trr_)rr_rr)rr;ryrrr*_type_affinityrrrr9rr:rrrrwr3)r1rrD has_regconfigrr{rr}s r2r3zts_headline.__init__sDz t9q=!M tAw 6 6 7Q ++u}}<"M M #**++ &*T640oo K'-KK    ++T640&*     ;3?? s9D) rOrPrQrRrrr*r3rrs@r2rrs "M D&@&@r5rDistinctOnClausect|S)aapply a DISTINCT_ON to a SELECT statement e.g.:: stmt = select(tbl).ext(distinct_on(t.c.some_col)) this supersedes the previous approach of using ``select(tbl).distinct(t.c.some_col))`` to apply a similar construct. .. versionadded:: 2.1 )r)rqs r2 distinct_onrs D !!r5c^eZdZUdZdZdej fgZded<d dZ d dZ d dZ y ) rr(postgresql_distinct_on _distinct_onr#r,c8tfd|D_y)Nc3jK|]*}tjtj|,yw))rN)rr9rByOfRole).0er1s r2 z,DistinctOnClause.__init__..7s/"    U^^Qd K K" s03)tupler)r1rs` r2r3zDistinctOnClause.__init__6s!"  "  r5c|jrtjd|jj ||j |j dy)NzHCannot mix ``select.ext(distinct_on(...))`` and ``select.distinct(...)`` pre_columns)rrInvalidRequestErrordistinctnon_generativeapply_syntax_extension_point_merge_other_distinct)r1 select_stmts r2apply_to_selectz DistinctOnClause.apply_to_select<sR  # #))+  ++K800  & &  r5cg}d}|D]3}t|tr||jz }#|j|5|r)|jt||jz|S|j||S)Nr/)ryrrrj)r1existingresto_mergers r2rz&DistinctOnClause._merge_other_distinctIs} A!-.ANN* 1    JJ'43D3D(DE F  JJt  r5N)rz(Sequence[_ColumnExpressionArgument[Any]])rzexpression.Select[Any]rMrN)r Sequence[elements.ClauseElement]rMr) rOrPrQrTrSrdp_clauseelement_tupler,rWr3rrr/r5r2rr.sM$-N *AAB3/  8 )r5N)rqrLrMr): __future__rtypingrrrrrr r r r rarrayrrsqlrrrrrrsql.baser sql.schemar sql.sqltypesr sql.visitorsr sql._typingrr sql.elementsrr sql.operatorsr sql.selectabler!r"r#r$r'r[rGenericFunctionrrrrrrrrrr/r5r2rs!# '4 -81---,26 T[G11"5[G|z2zz0@I--b1@:-,,m,},=,;@-;@| " ) (@(@)r5