liCFddlmZddlZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z d d l m Z d d l mZd d l mZddlmZddlmZddlmZddlm Z ddlmZe rTddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl"m#Z#ddl$m%Z%ddl&m'Z'ddl&m(Z(ddl&m)Z)ddl&m*Z*dd lm+Z+dd!l,m-Z-e d"e#Z.e d$e#Z/e j0fd7d-Ze j0fd7d.Z1Gd/d0ej2e.Z3Gd1d2ej4e.Z4d8d6Z5dS)9) annotationsN)Any)Iterable)Optional)Sequence) TYPE_CHECKING)TypeVar)Union) CONTAINED_BY)CONTAINS)OVERLAP)types)util) expression) operators)InternalTraversal)Dialect)_ColumnExpressionArgument)_TypeEngineArgument) ColumnElement)Grouping) BindParameter) OperatorType)_SelectIterable)_BindProcessorType)_LiteralProcessorType)_ResultProcessorType) TypeEngine)_TraverseInternalsType)Self_T)bound_CTother typing_Anyarrexpr_ColumnExpressionArgument[_T]operatorrreturnColumnElement[bool]c.|||S)zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method. See that method for details. )anyr&r(r*s [/var/www/findabus/venv/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/array.pyrr2 ;;uh ' ''c.|||S)zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method. See that method for details. )allr/s r0Allr5?r1r2ceZdZUdZdZdZdejfdejfgZ de d<dddfdZ e d dZ d!d"dZ d#d$dZxZS)%arrayaA PostgreSQL ARRAY literal. This is used to produce ARRAY literals in SQL expressions, e.g.:: from sqlalchemy.dialects.postgresql import array from sqlalchemy.dialects import postgresql from sqlalchemy import select, func stmt = select(array([1, 2]) + array([3, 4, 5])) print(stmt.compile(dialect=postgresql.dialect())) Produces the SQL: .. sourcecode:: sql SELECT ARRAY[%(param_1)s, %(param_2)s] || ARRAY[%(param_3)s, %(param_4)s, %(param_5)s]) AS anon_1 An instance of :class:`.array` will always have the datatype :class:`_types.ARRAY`. The "inner" type of the array is inferred from the values present, unless the :paramref:`_postgresql.array.type_` keyword argument is passed:: array(["foo", "bar"], type_=CHAR) When constructing an empty array, the :paramref:`_postgresql.array.type_` argument is particularly important as PostgreSQL server typically requires a cast to be rendered for the inner type in order to render an empty array. SQLAlchemy's compilation for the empty array will produce this cast so that:: stmt = array([], type_=Integer) print(stmt.compile(dialect=postgresql.dialect())) Produces: .. sourcecode:: sql ARRAY[]::INTEGER[] As required by PostgreSQL for empty arrays. .. versionadded:: 2.0.40 added support to render empty PostgreSQL array literals with a required cast. Multidimensional arrays are produced by nesting :class:`.array` constructs. The dimensionality of the final :class:`_types.ARRAY` type is calculated by recursively adding the dimensions of the inner :class:`_types.ARRAY` type:: stmt = select( array( [array([1, 2]), array([3, 4]), array([column("q"), column("x")])] ) ) print(stmt.compile(dialect=postgresql.dialect())) Produces: .. sourcecode:: sql SELECT ARRAY[ ARRAY[%(param_1)s, %(param_2)s], ARRAY[%(param_3)s, %(param_4)s], ARRAY[q, x] ] AS anon_1 .. versionadded:: 1.3.6 added support for multidimensional array literals .. seealso:: :class:`_postgresql.ARRAY` postgresqlclausestyper!_traverse_internalsN)type_ Iterable[_T]r<!Optional[_TypeEngineArgument[_T]]kwr'c Vtjtjg|Ri|||n$|jr|jdjn t j}t|tr.t|j |j |j dznd|_dSt||_dS)aConstruct an ARRAY literal. :param clauses: iterable, such as a list, containing elements to be rendered in the array :param type\_: optional type. If omitted, the type is inferred from the contents of the array. Nrr ) dimensions) super__init__rcomma_opr9r:sqltypesNULLTYPE isinstanceARRAY item_typerB)selfr9r<r? main_type __class__s r0rDzarray.__init__s +z%array._bind_param..sI$$ !D%r2)rgetitemrrr:r7)rKr*rSr<rUs`` ` r0r]zarray._bind_params  X):::+&."&)  !  r2againstOptional[OperatorType]Union[Self, Grouping[_T]]cx|tjtjtjfvrt j|S|SrO)rany_opall_oprarr)rKrbs r0 self_groupzarray.self_groups5 y')99;LM M M&t,, ,Kr2)r9r=r<r>r?r')r+r)NF) r*rrSr'r<rTrUrVr+rWrO)rbrcr+rd)__name__ __module__ __qualname____doc____visit_name__stringify_dialectrdp_clauseelement_tupledp_typer;__annotations__rDpropertyrRr]rh __classcell__)rMs@r0r7r7LsKKZN$ %<= "*+348 !)!)!)!)!)!)!)!)FX+/$ 815r2r7ceZdZdZ ddd ZGd d ejjeZeZ e j ddZ ddZ ddZddZdS) rIan PostgreSQL ARRAY type. The :class:`_postgresql.ARRAY` type is constructed in the same way as the core :class:`_types.ARRAY` type; a member type is required, and a number of dimensions is recommended if the type is to be used for more than one dimension:: from sqlalchemy.dialects import postgresql mytable = Table( "mytable", metadata, Column("data", postgresql.ARRAY(Integer, dimensions=2)), ) The :class:`_postgresql.ARRAY` type provides all operations defined on the core :class:`_types.ARRAY` type, including support for "dimensions", indexed access, and simple matching such as :meth:`.types.ARRAY.Comparator.any` and :meth:`.types.ARRAY.Comparator.all`. :class:`_postgresql.ARRAY` class also provides PostgreSQL-specific methods for containment operations, including :meth:`.postgresql.ARRAY.Comparator.contains` :meth:`.postgresql.ARRAY.Comparator.contained_by`, and :meth:`.postgresql.ARRAY.Comparator.overlap`, e.g.:: mytable.c.data.contains([1, 2]) Indexed access is one-based by default, to match that of PostgreSQL; for zero-based indexed access, set :paramref:`_postgresql.ARRAY.zero_indexes`. Additionally, the :class:`_postgresql.ARRAY` type does not work directly in conjunction with the :class:`.ENUM` type. For a workaround, see the special type at :ref:`postgresql_array_of_enum`. .. container:: topic **Detecting Changes in ARRAY columns when using the ORM** The :class:`_postgresql.ARRAY` type, when used with the SQLAlchemy ORM, does not detect in-place mutations to the array. In order to detect these, the :mod:`sqlalchemy.ext.mutable` extension must be used, using the :class:`.MutableList` class:: from sqlalchemy.dialects.postgresql import ARRAY from sqlalchemy.ext.mutable import MutableList class SomeOrmClass(Base): # ... data = Column(MutableList.as_mutable(ARRAY(Integer))) This extension will allow "in-place" changes such to the array such as ``.append()`` to produce events which will be detected by the unit of work. Note that changes to elements **inside** the array, including subarrays that are mutated in place, are **not** detected. Alternatively, assigning a new array value to an ORM element that replaces the old one will always trigger a change event. .. seealso:: :class:`_types.ARRAY` - base array type :class:`_postgresql.array` - produces a literal array value. FNrJ_TypeEngineArgument[_T]as_tuplerVrB Optional[int] zero_indexesct|trtdt|tr |}||_||_||_||_dS)a-Construct an ARRAY. E.g.:: Column("myarray", ARRAY(Integer)) Arguments are: :param item_type: The data type of items of this array. Note that dimensionality is irrelevant here, so multi-dimensional arrays like ``INTEGER[][]``, are constructed as ``ARRAY(Integer)``, not as ``ARRAY(ARRAY(Integer))`` or such. :param as_tuple=False: Specify whether return results should be converted to tuples from lists. DBAPIs such as psycopg2 return lists by default. When tuples are returned, the results are hashable. :param dimensions: if non-None, the ARRAY will assume a fixed number of dimensions. This will cause the DDL emitted for this ARRAY to include the exact number of bracket clauses ``[]``, and will also optimize the performance of the type overall. Note that PG arrays are always implicitly "non-dimensioned", meaning they can store any number of dimensions no matter how they were declared. :param zero_indexes=False: when True, index values will be converted between Python zero-based and PostgreSQL one-based indexes, e.g. a value of one will be added to all index values before passing to the database. zUDo not nest ARRAY types; ARRAY(basetype) handles multi-dimensional arrays of basetypeN)rHrI ValueErrorr:rJrvrBrx)rKrJrvrBrxs r0rDzARRAY.__init__6spN i ' ' ?  i & & $! I"  $(r2c*eZdZdZd dZd dZd d Zd S) ARRAY.Comparatora*Define comparison operations for :class:`_types.ARRAY`. Note that these operations are in addition to those provided by the base :class:`.types.ARRAY.Comparator` class, including :meth:`.types.ARRAY.Comparator.any` and :meth:`.types.ARRAY.Comparator.all`. r&r'kwargsr+r,c P|t|tjS)zBoolean expression. Test if elements are a superset of the elements of the argument array expression. kwargs may be ignored by this operator but are required for API conformance.  result_type)operater rFBoolean)rKr&r}s r0containszARRAY.Comparator.containsss<<%X=M<NN Nr2cP|t|tjS)zBoolean expression. Test if elements are a proper subset of the elements of the argument array expression. r)rr rFrrKr&s r0 contained_byzARRAY.Comparator.contained_by~s)<<e1A  r2cP|t|tjS)zuBoolean expression. Test if array has elements in common with an argument array expression. r)rrrFrrs r0overlapzARRAY.Comparator.overlaps<<H.to_strs2DIIh//222 2r2valueSequence[typing_Any]cB|j}|SrO)_apply_item_processorrB)rinner item_procrKrs r0processz(ARRAY.literal_processor..processs*..y$/6ELr2)rrr+r)rrr+r)rJ dialect_implliteral_processor)rKrrrrs` @@r0rzARRAY.literal_processorsN//88JJ     4 3 3 3 3         r22Optional[_BindProcessorType[Sequence[typing_Any]]]crj||dfd }|S)NrOptional[Sequence[typing_Any]]r+Optional[list[typing_Any]]cP||S|jtSrO)rrBlistrrrKs r0rz%ARRAY.bind_processor..processs2} 119dotr2)rrr+r)rJrbind_processor)rKrrrs` @r0rzARRAY.bind_processorsXN//88GG          r2coltypeobject*_ResultProcessorType[Sequence[typing_Any]]cj|||d fd }jr#|t jdd fd d fd }|S) Nrrr+rcl||S|jjrtntSrO)rrBrvtuplerrs r0rz'ARRAY.result_processor..processs@} 11O!]4EE r2z^{(.*)}$rSequence[Optional[str]]cr|d}t|S)Nr )matchgroup_split_enum_values)rrpatterns r0handle_raw_stringz1ARRAY.result_processor..handle_raw_strings0 e,,22155)%000r2cb||St|tr |n|SrO)rHr)rrsuper_rps r0rz'ARRAY.result_processor..processsK= L x!%--%%e,,,r2)rrr+r)rrr+r)rJrresult_processorrrecompile)rKrrrrrrrs` @@@@r0rzARRAY.result_processorsN//88II W           $ Hj--G 1 1 1 1 1 1       r2)FNF)rJrurvrVrBrwrxrV)r+rV)rrr+r)rrr+r)rrrrr+r)rirjrkrlrDrFrIrr%comparator_factoryrmemoized_propertyrrrrrPr2r0rIrIsEET$(" 1)1)1)1)1)f!N!N!N!N!NX^.s3!N!N!NF$     (&******r2rI array_stringrrcd|vr#d|r|dngDS|dd}|dd}g}tjd|}d }|D]j}|dkr| } |r*||dd8|d tjd |Dk|S) N"c"g|] }|dkr|nd SNULLNrPr^rs r0r`z&_split_enum_values..s4   fAA$   r2,z\"z _$ESC_QUOTE$_z\\\z(")Fc"g|] }|dkr|nd SrrPrs r0r`z&_split_enum_values..s4fAA$r2z ([^\s,]+),?)splitreplacerappendextendfindall)rtextresult on_quotes in_quotestoks r0rrs# ,  1=El((---2        7 7D <<t $ $D F&&II   #::% II   MM#++os;; < < < < MMZ<<     Mr2)r&r'r(r)r*rr+r,)rrr+r)6 __future__rrtypingrr'rrrrr r rr r rrrFrsqlr sql.visitorsrengine.interfacesr sql._typingrr sql.elementsrrsql.expressionr sql.operatorsrsql.selectabler sql.type_apirrrr r! util.typingr"r#r%eqr5ExpressionClauseListr7rIrrPr2r0rs1#""""" $$$$$$ ######!!!!!!------$,,,,,,888888222222------((((((//////------111111222222555555444444******666666###### WT$$$ ge:&&& '\ ( ( ( ( ( '\ ( ( ( ( (_____J +B /___DxxxxxHN2 xxxvr2