o hZB@sddlmZddlZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z d d l m Z d d l mZd d l mZddlmZddlmZddlmZddlm Z ddlmZe rddlmZddlmZddlmZddlmZddlmZddl 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"ed#Z.e j/fd9d,d-Ze j/fd9d.d/Z0Gd0d1d1ej1e.Z2Gd2d3d3ej3e.Z3d:d7d8Z4dS);) 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)boundother typing_Anyarrexpr_ColumnExpressionArgument[_T]operatorrreturnColumnElement[bool]cC |||S)zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method. See that method for details. )anyr$r&r(r.x/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/array.pyr1 rcCr+)zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method. See that method for details. )allr-r.r.r/All>r0r2cszeZdZUdZdZdZdejfdejfgZ de d<ddd#fddZ e d$ddZ  d%d&ddZ d'd(d!d"ZZS))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]r8!Optional[_TypeEngineArgument[_T]]kwr%c stjtjg|Ri||dur|n |jr|jdjntj}t|t r9t |j |j dur2|j dndd|_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_opr5r6sqltypesNULLTYPE isinstanceARRAY item_typer=)selfr5r8r; main_type __class__r.r/r?s     zarray.__init__r)rcCs|fSNr.rFr.r.r/_select_iterableszarray._select_iterableFr(robjOptional[TypeEngine[_T]]_assume_scalarboolBindParameter[_T]cs@|stjurtjd|jddStfdd|DS)NT)_compared_to_operatorr8_compared_to_typeuniquecsg|] }j|ddqS)T)rOr8) _bind_param).0or(rFr8r.r/ s z%array._bind_param..)rgetitemrrr6r3)rFr(rMr8rOr.rXr/rUs zarray._bind_paramagainstOptional[OperatorType]Union[Self, Grouping[_T]]cCs"|tjtjtjfvrt|S|SrJ)rany_opall_oprZrr)rFr[r.r.r/ self_groups zarray.self_group)r5r9r8r:r;r%)r)r)NF) r(rrMr%r8rNrOrPr)rQrJ)r[r\r)r])__name__ __module__ __qualname____doc____visit_name__stringify_dialectrdp_clauseelement_tupledp_typer7__annotations__r?propertyrLrUr` __classcell__r.r.rHr/r3Ks M  #  r3c@sleZdZdZ   dd d d ZGd ddejjeZeZ e j d!ddZ d"ddZ d#ddZd$ddZdS)%rDan 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. FNrE_TypeEngineArgument[_T]as_tuplerPr= Optional[int] zero_indexescCs>t|tr tdt|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)rCrD ValueErrorr6rErmr=ro)rFrErmr=ror.r.r/r?5s '  zARRAY.__init__c@s.eZdZdZdddZdd d Zdd d Zd S)zARRAY.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*cK|jt|tjdS)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 rABoolean)rFr$rqr.r.r/containsrs zARRAY.Comparator.containscCrr)zBoolean expression. Test if elements are a proper subset of the elements of the argument array expression. rs)rur rArvrFr$r.r.r/ contained_by}szARRAY.Comparator.contained_bycCrr)zuBoolean expression. Test if array has elements in common with an argument array expression. rs)rur rArvrxr.r.r/overlapszARRAY.Comparator.overlapN)r$r%rqr%r)r*)r$r%r)r*)rarbrcrdrwryrzr.r.r.r/ Comparatorhs  r{r)cCst|jtjo |jjSrJ)rCrErAEnum native_enumrKr.r.r/_against_native_enumszARRAY._against_native_enumdialectr#Optional[_LiteralProcessorType[_T]]cs>j||durdSd ddd fd d }|S) NelementsIterable[typing_Any]r)strcSsdd|dS)NzARRAY[z, ])join)rr.r.r/to_strsz'ARRAY.literal_processor..to_strvalueSequence[typing_Any]cs|j}|SrJ)_apply_item_processorr=rinner item_procrFrr.r/processs z(ARRAY.literal_processor..process)rrr)r)rrr)r)rE dialect_implliteral_processorrFrrr.rr/rs  zARRAY.literal_processor2Optional[_BindProcessorType[Sequence[typing_Any]]]cs&j||dfdd }|S)NrOptional[Sequence[typing_Any]]r)Optional[list[typing_Any]]cs|dur|S|jtSrJ)rr=listrrrFr.r/rs  z%ARRAY.bind_processor..process)rrr)r)rErbind_processorrr.rr/rs  zARRAY.bind_processorcoltypeobject*_ResultProcessorType[Sequence[typing_Any]]csZj|||d fdd }jr+|tddfd d d fd d }|S)Nrrr)rcs*|dur|S|jjrtStSrJ)rr=rmtuplerrrr.r/rsz'ARRAY.result_processor..processz^{(.*)}$r list[str]cs|d}t|S)Nr )matchgroup_split_enum_valuesr)patternr.r/handle_raw_stringsz1ARRAY.result_processor..handle_raw_stringcs(|dur|St|tr|S|SrJ)rCrr)rsuper_rpr.r/rs)rrr)r)rrr)r)rErresult_processorr~recompile)rFrrrr.)rrrrFrr/rs   zARRAY.result_processor)FNF)rErlrmrPr=rnrorP)r)rP)rrr)r)rrr)r)rrrrr)r)rarbrcrdr?rArDr{r"comparator_factoryrmemoized_propertyr~rrrr.r.r.r/rDsJ 3#   rD array_stringrrcCsd|vr |r |dSgS|dd}|dd}g}td|}d}|D]}|dkr/| }q%|r;||ddq%|td |q%|S) N",z\"z _$ESC_QUOTE$_z\\\z(")Fz ([^\s,]+),?)splitreplacerappendextendfindall)rtextresult on_quotes in_quotestokr.r.r/rs   r)r$r%r&r'r(rr)r*)rrr)r)5 __future__rrtypingrr%rrrrrr rr r r rrArsqlr sql.visitorsrengine.interfacesr sql._typingrr sql.elementsrrsql.expressionr sql.operatorsrsql.selectabler sql.type_apirrrrr util.typingr!r"eqr2ExpressionClauseListr3rDrr.r.r.r/sT                                  #|