,hCXSSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJ r S S K J r S S K J r S S KJr S SKJr S SKJr S SKJr S SKJr S SKJr S SKJr S SKJr S SKJr \(a*S SKJr S SKJr S SKJr S SK J!r! S SK"J#r# S SKJ$r$ S SKJ%r% \ "S\S9r&"SS \R>\&5r'"S!S"\5r(S#r)"S$S%\RT\&5r+"S&S'\+5r,"S(S)\+5r-"S*S+\+5r."S,S-\+5r/"S.S/\+5r0"S0S1\+5r1g2)3) annotations)Any)Iterable)List)Optional)overload) TYPE_CHECKING)TypeVar)types)ARRAY) coercions)elements) expression) functions)roles)schema)ColumnCollectionConstraint)TEXT)InternalTraversal)_ColumnExpressionArgument) ClauseElement) ColumnElement) OperatorType) FromClause)_CloneCallableType)_TraverseInternalsType_T)boundc*\rSrSr%SrSrSrS\R4S\R4S\R4/r S\ S'\ SS j5r \ SS j5r SS jr SSS jjrSSjr\R"4SSjjr\SSj5rSrg )aggregate_order_by*aRepresent 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; Similarly:: expr = func.string_agg( table.c.a, aggregate_order_by(literal_column("','"), table.c.a) ) stmt = select(expr) Would represent: .. sourcecode:: sql SELECT string_agg(a, ',' ORDER BY a) FROM table; .. versionchanged:: 1.2.13 - the ORDER BY argument may be multiple terms .. seealso:: :class:`_functions.array_agg` postgresqltargettypeorder_byr_traverse_internalscgNselfr%r's Z/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/dialects/postgresql/ext.py__init__aggregate_order_by.__init__X  cgr*r+r,s r.r/r0_r1r2c[R"[RU5UlURR Ul[ U5nU US:Xa [S5eUS:Xa.[R"[RUS5Ulg[R"US[R06Ulg)Nrz)at least one ORDER BY element is requiredr _literal_as_text_role) rexpectrExpressionElementRoler%r&len TypeErrorr'r ClauseList)r-r%r'_lobs r.r/r0fs &/%5%5  ' '&  KK$$ 8} 19GH H QY%,,++Xa[DM%//161L1LDMr2NcU$r*r+)r-againsts r. self_groupaggregate_order_by.self_group}s  r2c 2URUR4$r*r%r')r-kwargss r. get_childrenaggregate_order_by.get_childrens{{DMM))r2c dU"UR40UD6UlU"UR40UD6Ulgr*rA)r-clonekws r._copy_internals"aggregate_order_by._copy_internalss.DKK.2. dmm2r2 r2c\URRURR-$r*)r% _from_objectsr')r-s r.rK aggregate_order_by._from_objectss!{{((4==+F+FFFr2)r'r%r&)r%zColumnElement[_T]r'_ColumnExpressionArgument[Any])r%z_ColumnExpressionArgument[_T]r'rMr*)r=zOptional[OperatorType]returnr)rBrrNzIterable[ClauseElement])rFrrGrrNNone)rNzList[FromClause])__name__ __module__ __qualname____firstlineno____doc____visit_name__stringify_dialectrdp_clauseelementdp_typer(__annotations__rr/r>rCr_clonerHpropertyrK__static_attributes__r+r2r.r"r"*s"H*N$ $556 "**+ &7783/  ! 2   - 2  -2015-  *+3//3'3AD3 3 GGr2r"cz^\rSrSrSrSrSrSrSr\ R"SSS 5S 5r U4S jr SS jr S rU=r$)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/n/n0Ul[U6upV[[R"[R U5U5HRuupxpn U bUR U 5 Ub UROU n U bXRU 'UR X|U 45 MT X@l[R"U/UQ7URS5URS5URS5S.6 URSS5Ul URS5n U b*[R"[RU 5UlURS 05Ulg) a 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 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. .. versionadded:: 1.3.21 .. seealso:: :ref:`postgresql_operator_classes` - general description of how PostgreSQL operator classes are specified. Nname deferrable initially)rcrdreusinggistraops) operatorszipr expect_col_expression_collectionrDDLConstraintColumnRoleappendrc _render_exprsrr/getrfr6StatementOptionRolerarh)r-rrGcolumns render_exprs expressionsriexprcolumnstrname add_elementoperatorrcras r.r/ExcludeConstraint.__init__s@~ !$h >A  6 6--{   ? : 0T7( &{+"("46;;'D'/t$   X 6 7? "*"++   vvl+ff[)  VVGV, w  "))%*C*CUKDJ66%$r2c >[TU]U5 URVVVs/sH/up4n[U[5(dUOUR UUU4PM1 snnnUlgs snnnfr*)super _set_parentrn isinstancestrc)r-tablerGrtrcrx __class__s r.r|ExcludeConstraint._set_parent'sg E"*.););  *<$H 'tS11uwwt}  *<   s6A"c vURVVVs/sH)up4n[R"X0RU5U4PM+ nnnnUR"UUR UR URURURS.6nURRUR5 U$s snnnf)N)rcrdrerarf) rnr_copy_expressionparentrrcrdrerarfdispatch_update)r- target_tablerGrt_rxrrs r._copyExcludeConstraint._copy3s &*%7%7  &8!''kk<H &8   NN nn****   4==)! s0B4)rnrirhrfrar*)rPrQrRrSrTrUra inherit_cachecreate_drop_stringify_dialectr_document_text_coercionr/r|rr\ __classcell__rs@r.r^r^sW*N EM$0! %%%. %  %B  r2r^cT[US'[RR"U0UD6$)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)r rfunc array_agg)argrGs r.rrGs)!&B >> # #S /B //r2c,^\rSrSrSrU4SjrSrU=r$) _regconfig_fniRTc >[U5n[U5S:aR[R"[R UR S5[USS5U[RS9nU/nO/nUVs/sH3n[R"[R U[USS5US9PM5 nn[TU],"X5-0UD6 gs snf)Nr rrc)rcapply_propagate_attrstype_rcr) listr8rr6rr7popgetattrr REGCONFIGr{r/)r-argsrB initial_argr addtl_argsrs r.r/_regconfig_fn.__init__UsDz t9q=#**++ T640&*oo K'-KK    ++T640&*      ;3?? s4:Cr+)rPrQrRrSrr/r\rrs@r.rrRsM@@r2rc4\rSrSrSrSr\RrSr g) to_tsvectorioaThe 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 Tr+N) rPrQrRrSrTrr TSVECTORr&r\r+r2r.rros"M >>Dr2rc4\rSrSrSrSr\RrSr g) to_tsqueryiaThe 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 Tr+N rPrQrRrSrTrr TSQUERYr&r\r+r2r.rr"M ==Dr2rc4\rSrSrSrSr\RrSr g)plainto_tsqueryiaThe 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 Tr+Nrr+r2r.rrrr2rc4\rSrSrSrSr\RrSr g)phraseto_tsqueryiaThe 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 Tr+Nrr+r2r.rrrr2rc4\rSrSrSrSr\RrSr g)websearch_to_tsqueryiaThe 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 Tr+Nrr+r2r.rrrr2rc4^\rSrSrSrSr\rU4SjrSr U=r $) ts_headlineiaThe 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 F>[U5n[U5S:aSnOQ[US[R5(a-USR R [RLaSnOSnU(aR[R"[RURS5U[USS5[RS9nU/nO/nUVs/sH3n[R"[RU[USS5US9PM5 nn[ TU]D"XF-0UD6 gs snf) NFr Trrc)rrcrr)rr8r}rrr&_type_affinityr rrr6rr7rrrr{r/)r-rrB has_regconfigrrrrs r.r/ts_headline.__init__sDz t9q=!M tAw 6 6 7 7Q ++u}}<"M M #**++ &*T640oo K'-KK    ++T640&*      ;3?? s:Dr+) rPrQrRrSrTrrr&r/r\rrs@r.rrs "M D&@&@r2rN)2 __future__rtypingrrrrrr r r arrayr sqlrrrrrr sql.schemar sql.sqltypesr sql.visitorsr sql._typingr sql.elementsrr sql.operatorsrsql.selectablerrrrr"r^rGenericFunctionrrrrrrrr+r2r.rs# 4 -8---,26 TcG11"5cGLt2tn0@I--b1@:-,,m,},=,;@-;@r2