o LDiID@sddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z dd lm Z d d l m Z d d l mZd dlmZd dlmZd dlmZd dlmZd dlmZd dlmZd dlmZd dlmZd dlmZe rd dlmZd dlmZd dlm Z d dlm!Z!d dl"m#Z#d dl$m%Z%d dlm&Z&d dlm'Z'e ded Z(Gd!d"d"ej!e(Z)Gd#d$d$eZ*d%d&Z+Gd'd(d(ej,e(Z-Gd)d*d*e-Z.Gd+d,d,e-Z/Gd-d.d.e-Z0Gd/d0d0e-Z1Gd1d2d2e-Z2Gd3d4d4e-Z3d5S)6) annotations)Any)Iterable)List)Optional)overload)Tuple) TYPE_CHECKING)TypeVar)types)ARRAY) coercions)elements) expression) functions)roles)schema)ColumnCollectionConstraint)TEXT)InternalTraversal)_ColumnExpressionArgument)_DDLColumnArgument) ClauseElement) ColumnElement) OperatorType) FromClause)_CloneCallableType)_TraverseInternalsType_T)boundc@seZdZUdZdZdZdejfdejfdejfgZ de d<e d$d d Z e d%d d Z d%dd Z d&d'ddZ d(ddZejfd)dd Zed*d"d#ZdS)+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]cGdSNselfr$r&r,r,n/var/www/www-root/data/www/77.83.87.30/venv/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/ext.py__init__Zzaggregate_order_by.__init___ColumnExpressionArgument[_T]cGr*r+r,r-r,r,r/r0ar1cGsnttj||_|jj|_t|}||dkrtd|dkr+ttj|d|_dSt j |dtji|_dS)Nrz)at least one ORDER BY element is requiredr _literal_as_text_role) rexpectrExpressionElementRoler$r%len TypeErrorr&r ClauseList)r.r$r&_lobr,r,r/r0hs"    NagainstOptional[OperatorType]returnrcCs|Sr+r,)r.r:r,r,r/ self_groupszaggregate_order_by.self_groupkwargsrIterable[ClauseElement]cKs |j|jfSr+r$r&)r.r>r,r,r/ get_childrens zaggregate_order_by.get_childrenclonerkwNonecKs,||jfi||_||jfi||_dSr+r@)r.rBrCr,r,r/_copy_internalssz"aggregate_order_by._copy_internalsList[FromClause]cCs|jj|jjSr+)r$ _from_objectsr&r.r,r,r/rGsz aggregate_order_by._from_objects)r$r(r&r))r$r2r&r)r+)r:r;r<r)r>rr<r?)rBrrCrr<rD)r<rF)__name__ __module__ __qualname____doc____visit_name__stringify_dialectrdp_clauseelementdp_typer'__annotations__rr0r=rAr_clonerEpropertyrGr,r,r,r/r",s( $      r"csReZdZdZdZdZdZdZe ddddddZ fddZ dddZ 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`rTuple[_DDLColumnArgument, str]rCrr<rDcOsg}g}i|_t|\}}tttj||D]+\\}}} } } | dur(|| |dur/|jn| } | dur:| |j| <||| | fq||_t j |g|R| d| d| dd| dd|_ | d} | durut 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)rXrYrZusinggistrVops) operatorszipr expect_col_expression_collectionrDDLConstraintColumnRoleappendrX _render_exprsrr0getr[r4StatementOptionRolerVr])r.rrCcolumns render_exprs expressionsr^exprcolumnstrname add_elementoperatorrXrVr,r,r/r0s>a    zExcludeConstraint.__init__c s&tfdd|jD|_dS)Ncs0g|]\}}}t|ts|nj|||fqSr,) isinstancestrc).0rirXrmtabler,r/ .sz1ExcludeConstraint._set_parent..)super _set_parentrc)r.rsrC __class__rrr/rv+s   zExcludeConstraint._set_parentc sJfddjD}j|jjjjjd}|jj|S)Ncs&g|]\}}}t|j|fqSr,)r_copy_expressionparent)rqri_rmr. target_tabler,r/rt8s z+ExcludeConstraint._copy..)rXrYrZrVr[) rcrxrXrYrZrVr[dispatch_update)r.r}rCrrpr,r|r/_copy7s zExcludeConstraint._copy)rrWrCrr<rDr+)rIrJrKrLrMrV inherit_cachecreate_drop_stringify_dialectr_document_text_coercionr0rvr __classcell__r,r,rwr/rTs    rTcOst|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)argrCr,r,r/rKsrcs eZdZdZfddZZS) _regconfig_fnTcsrt|}t|dkr!tjtj|dtddtj d}|g}ng}fdd|D}t j ||i|dS)Nr rrX)rXapply_propagate_attrstype_c (g|]}tjtj|tdddqSrXN)rXrrr4rr5getattrrqrprHr,r/rtg z*_regconfig_fn.__init__..) listr6rr4rr5poprr REGCONFIGrur0)r.argsr> initial_arg addtl_argsrwrHr/r0Ys    z_regconfig_fn.__init__)rIrJrKrr0rr,r,rwr/rVsrc@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)rIrJrKrLrr TSVECTORr%r,r,r,r/rs rc@r) 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 TNrIrJrKrLrr TSQUERYr%r,r,r,r/rrrc@r)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,r,r,r/rrrc@r)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,r,r,r/rrrc@r)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,r,r,r/rrrcs(eZdZdZdZeZfddZZS) 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 Tcst|}t|dkr d}nt|dtjr!|djjtjur!d}nd}|r.)rr6rnrrr%_type_affinityr rrr4rr5rrrrur0)r.rr> has_regconfigrrrwrHr/r0s,    zts_headline.__init__) rIrJrKrLrrr%r0rr,r,rwr/rs rN)4 __future__rtypingrrrrrrr r r arrayr sqlrrrrrr sql.schemar sql.sqltypesr sql.visitorsr sql._typingrr sql.elementsrr sql.operatorsrsql.selectablerrrr r"rTrGenericFunctionrrrrrrrr,r,r,r/sR                             f: