ihCddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z d d l m Z d d l m Z d d lmZd dlmZd dlmZd dlmZd dlmZd dlmZd dlmZd dlmZd dlmZer*d dlmZd dlmZd dlmZd dl m!Z!d dl"m#Z#d dlm$Z$d dlm%Z%e deZ&Gdd eje&Z'Gd!d"eZ(d#Z)Gd$d%ej*e&Z+Gd&d'e+Z,Gd(d)e+Z-Gd*d+e+Z.Gd,d-e+Z/Gd.d/e+Z0Gd0d1e+Z1d2S)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)boundceZdZUdZdZdZdejfdejfdejfgZ de d<e dd Z e d d Z d d Z d!d"dZ d#dZejfd$dZed%dZdS)&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; 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_internalsColumnElement[_T]_ColumnExpressionArgument[Any]cdSNselfr$r&s j/var/www/html/services/rag-service/venv/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/ext.py__init__zaggregate_order_by.__init__X  s_ColumnExpressionArgument[_T]cdSr+r,r-s r/r0zaggregate_order_by.__init___r1r2c`tjtj||_|jj|_t |}||dkrtd|dkr,tjtj|d|_dStj |dtji|_dS)Nrz)at least one ORDER BY element is requiredr _literal_as_text_role) rexpectrExpressionElementRoler$r%len TypeErrorr&r ClauseList)r.r$r&_lobs r/r0zaggregate_order_by.__init__fs &/%5  '& &  K$ 8}} $ 199GHH H QYY%,+Xa[DMMM%/161LDMMMr2NagainstOptional[OperatorType]returnrc|Sr+r,)r.r=s r/ self_groupzaggregate_order_by.self_group}s  r2kwargsrIterable[ClauseElement]c |j|jfSr+r$r&)r.rBs r/ get_childrenzaggregate_order_by.get_childrens{DM))r2clonerkwNonec R||jfi||_||jfi||_dSr+rE)r.rGrHs r/_copy_internalsz"aggregate_order_by._copy_internalss>eDK..2.. dm22r22 r2List[FromClause]c4|jj|jjzSr+)r$ _from_objectsr&)r.s r/rNz aggregate_order_by._from_objectss{(4=+FFFr2)r$r(r&r))r$r3r&r)r+)r=r>r?r)rBrr?rC)rGrrHrr?rI)r?rL)__name__ __module__ __qualname____doc____visit_name__stringify_dialectrdp_clauseelementdp_typer'__annotations__rr0rArFr_clonerKpropertyrNr,r2r/r"r"*s:""H*N$ $56 "*+ &783    X    X 015 ****+3/33333 GGGXGGGr2r"cpeZdZdZdZdZdZdZej dddd 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`cg}g}i|_t|\}}ttjtj||D]P\\}}} } } | || ||jn| } | | |j| <||| | fQ||_tj |g|R| d| d| dd| dd|_ | d} | $tj tj| |_| d i|_dS) 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)r_r`rausinggistr]ops) operatorszipr expect_col_expression_collectionrDDLConstraintColumnRoleappendr_ _render_exprsrr0getrbr7StatementOptionRoler]rd)r.rrHcolumns render_exprs expressionsreexprcolumnstrname add_elementoperatorr_r]s r/r0zExcludeConstraint.__init__s~ !$h Y>A  6-{    ? ?  8 8 : 0T67K( &{+++"("46;;'D'/t$   tX 6 7 7 7 7)"+    vvl++ff[))     VVGV,, w  ")%*CUKKDJ66%$$r2c |tfd|jD|_dS)Ncfg|]-\}}}t|ts|n j|||f.Sr,) isinstancestrc).0rpr_rttables r/ z1ExcludeConstraint._set_parent..*sU   %dH 'tS11Duwt}    r2)super _set_parentrj)r.r{rH __class__s ` r/r~zExcludeConstraint._set_parent'sR E"""    *.);    r2c fdjD}j|jjjjjd}|jj|S)NcRg|]#\}}}tj|j|f$Sr,)r_copy_expressionparent)rzrp_rtr. target_tables r/r|z+ExcludeConstraint._copy..4sJ   "a'dk<HH    r2)r_r`rar]rb) rjrr_r`rar]rbdispatch_update)r.rrHrrys`` r/_copyzExcludeConstraint._copy3s     &*%7     DN n**     4=)))r2r+)rOrPrQrRrSr] inherit_cachecreate_drop_stringify_dialectr_document_text_coercionr0r~r __classcell__rs@r/r[r[s*N EM$0!%X%%. %%  %B      r2r[cBt|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)r rfunc array_agg)argrHs r/rrGs'!&B > #S /B / //r2c"eZdZdZfdZxZS) _regconfig_fnTc Lt|}t|dkrStjtj|dtddtj }|g}ng}fd|D}tj ||zi|dS)Nr rr_)r_apply_propagate_attrstype_c rg|]3}tjtj|t dd4Sr_N)r_rrr7rr8getattrrzryr.s r/r|z*_regconfig_fn.__init__..cX     +T6400&*       r2) listr9rr7rr8poprr REGCONFIGr}r0)r.argsrB initial_arg addtl_argsrs` r/r0z_regconfig_fn.__init__UsDzz t99q==#*+ T6400&*o K'-KKK        ;3??????r2)rOrPrQrr0rrs@r/rrRsFM@@@@@@@@@r2rc$eZdZdZdZejZdS) 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)rOrPrQrRrr TSVECTORr%r,r2r/rros&"M >DDDr2rc$eZdZdZdZejZdS) 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 TNrOrPrQrRrr TSQUERYr%r,r2r/rr&"M =DDDr2rc$eZdZdZdZejZdS)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,r2r/rrrr2rc$eZdZdZdZejZdS)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,r2r/rrrr2rc$eZdZdZdZejZdS)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,r2r/rrrr2rc*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 t|}t|dkrd}nCt|dtjr!|djjtjurd}nd}|rStj tj | dtddtj}|g}ng}fd|D}t!j||zi|dS) NFr Trr_)rr_rc rg|]3}tjtj|t dd4Srrrs r/r|z(ts_headline.__init__..rr2)rr9rwrrr%_type_affinityr rrr7rr8rrrr}r0)r.rrB has_regconfigrrrs` r/r0zts_headline.__init__sDzz t99q==!MM tAw 6 7 7 !Q +u}<<"MM M  #*+ &*T6400o K'-KKK        ;3??????r2) rOrPrQrRrrr%r0rrs@r/rrsW"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#""""" 444444 ------7888888------------------,,,,,,222222666666 WTcGcGcGcGcG1"5cGcGcGLttttt2tttn000@@@@@I-b1@@@:-,,m,},=,;@;@;@;@;@-;@;@;@;@;@r2