U hC@sddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm 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 dedZ&Gdd d eje&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+Z.Gd-d.d.e+Z/Gd/d0d0e+Z0Gd1d2d2e+Z1d3S)4) 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@seZdZUdZdZdZdejfdejfdejfgZ de d<e dd d d d Z e d d d dd Z d d d dd Z d$dddddZ dddddZejfddddddZed d!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_internalszColumnElement[_T]z_ColumnExpressionArgument[Any]r"r$cGsdSNselfr"r$r(r(F/tmp/pip-unpacked-wheel-y9ln43lq/sqlalchemy/dialects/postgresql/ext.py__init__Xszaggregate_order_by.__init__z_ColumnExpressionArgument[_T]cGsdSr'r(r)r(r(r+r,_scGsnttj||_|jj|_t|}||dkr8tdn2|dkrVttj|d|_nt j |dtji|_dS)Nrz)at least one ORDER BY element is requiredr Z_literal_as_text_role) rexpectrExpressionElementRoler"r#len TypeErrorr$rZ ClauseList)r*r"r$Z_lobr(r(r+r,fs&  NzOptional[OperatorType]r)againstreturncCs|Sr'r()r*r1r(r(r+ self_group}szaggregate_order_by.self_grouprzIterable[ClauseElement])kwargsr2cKs |j|jfSr'r&)r*r4r(r(r+ get_childrenszaggregate_order_by.get_childrenrNone)clonekwr2cKs$||jf||_||jf||_dSr'r&)r*r7r8r(r(r+_copy_internalssz"aggregate_order_by._copy_internalszList[FromClause])r2cCs|jj|jjSr')r" _from_objectsr$r*r(r(r+r:sz aggregate_order_by._from_objects)N)__name__ __module__ __qualname____doc____visit_name__Zstringify_dialectrZdp_clauseelementZdp_typer%__annotations__rr,r3r5rZ_cloner9propertyr:r(r(r(r+r *s& $ r csPeZdZdZdZdZdZdZe dddd d Z fd d Z dd dZ 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 Zexclude_constraintNFr!wherez:class:`.ExcludeConstraint`z$:paramref:`.ExcludeConstraint.where`cOsg}g}i|_t|\}}tttj||D]V\\}}} } } | dk rP|| |dk r^|jn| } | dk rt| |j| <||| | fq.||_t j |f|| d| d| dd| dd|_ | d} | dk rt 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)rErFrGusingZgistrDops) operatorsziprZ expect_col_expression_collectionrZDDLConstraintColumnRoleappendrE _render_exprsrr,getrHr-ZStatementOptionRolerDrI)r*rr8columnsZ render_exprsZ expressionsrJexprcolumnZstrnameZ add_elementoperatorrErDr(r(r+r,s@_    zExcludeConstraint.__init__c s&tfdd|jD|_dS)Ncs0g|](\}}}t|ts|nj|||fqSr() isinstancestrc).0rPrErRtabler(r+ *s z1ExcludeConstraint._set_parent..)super _set_parentrM)r*rXr8 __class__rWr+r['s  zExcludeConstraint._set_parentc sJfddjD}j|jjjjjd}|jj|S)Ncs&g|]\}}}t|j|fqSr()rZ_copy_expressionparent)rVrP_rRr* target_tabler(r+rY4sz+ExcludeConstraint._copy..)rErFrGrDrH) rMr]rErFrGrDrHdispatch_update)r*rar8rrUr(r`r+_copy3s zExcludeConstraint._copy)N)r<r=r>r?r@rD inherit_cacheZcreate_drop_stringify_dialectrZ_document_text_coercionr,r[rd __classcell__r(r(r\r+rCs   rCcOst|d<tjj||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. Z_default_array_type)r rfunc array_agg)argr8r(r(r+rhGsrhcs eZdZdZfddZZS) _regconfig_fnTcsnt|}t|dkrBtjtj|dtddtj d}|g}ng}fdd|D}t j |||dS)Nr rrE)rEapply_propagate_attrstype_c s(g|] }tjtj|tdddqSrEN)rErkrr-rr.getattrrVrUr;r(r+rYcs z*_regconfig_fn.__init__..) listr/rr-rr.popror REGCONFIGrZr,)r*argsr4 initial_arg addtl_argsr\r;r+r,Us    z_regconfig_fn.__init__)r<r=r>rer,rfr(r(r\r+rjRsrjc@seZdZdZdZejZdS) 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)r<r=r>r?rer ZTSVECTORr#r(r(r(r+rwosrwc@seZdZdZdZejZdS) 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 TNr<r=r>r?rer TSQUERYr#r(r(r(r+rxsrxc@seZdZdZdZejZdS)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 TNryr(r(r(r+r{sr{c@seZdZdZdZejZdS)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 TNryr(r(r(r+r|sr|c@seZdZdZdZejZdS)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 TNryr(r(r(r+r}sr}cs(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|dkrd}n,t|dtjrB|djjtjkrBd}nd}|rxt j t j | dtddtjd}|g}ng}fdd |D}tj|||dS) NFr TrrE)rkrErlc s(g|] }tjtj|tdddqSrmrnrpr;r(r+rYs z(ts_headline.__init__..)rqr/rSrrr#Z_type_affinityr rzrr-rr.rrrorsrZr,)r*rtr4Z has_regconfigrurvr\r;r+r,s.    zts_headline.__init__) r<r=r>r?rerr#r,rfr(r(r\r+r~sr~N)2 __future__rtypingrrrrrrr r arrayr ZsqlrrrrrrZ sql.schemarZ sql.sqltypesrZ sql.visitorsrZ sql._typingrZ sql.elementsrrZ sql.operatorsrZsql.selectablerrrrr rCrhZGenericFunctionrjrwrxr{r|r}r~r(r(r(r+sL                           f8