U ]g%iC@sddlmZddlZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z d d l m Z d d l mZd d l mZddlmZddlmZddlmZddlm Z ddlmZe rvddlmZddlmZddlmZddlmZddlmZddl 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 d$ed#Z/e j0fd%d&d'd(d)d*d+Ze j0fd%d&d'd(d)d,d-Z1Gd.d/d/ej2e.Z3Gd0d1d1ej4e.Z4d2d3d4d5d6Z5dS)7) 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_CT typing_Anyz_ColumnExpressionArgument[_T]rColumnElement[bool])otherarrexproperatorreturncCs |||S)zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method. See that method for details. )anyr'r(r)r-c/var/www/html/api-medvista/venv/lib/python3.8/site-packages/sqlalchemy/dialects/postgresql/array.pyr2s rcCs |||S)zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method. See that method for details. )allr,r-r-r.All?s r0cseZdZUdZdZdZdejfdejfgZ de d<ddd d d d fd dZ e ddddZ d dd ddddddZd!dddddZZS)"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_z Iterable[_T]z!Optional[_TypeEngineArgument[_T]]r%)r3r6kwc sxtjtjf|||dk r"|n|jr4|jdjntj}t|t rjt |j |j dk r^|j dndd|_n t ||_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__rZcomma_opr3r4sqltypesZNULLTYPE isinstanceARRAY item_typer9)selfr3r6r7Z main_type __class__r-r.r;s   zarray.__init__rr*cCs|fSNr-r@r-r-r._select_iterableszarray._select_iterableFrzOptional[TypeEngine[_T]]boolzBindParameter[_T])r)objr6_assume_scalarr*csD|stjkr&tjd|jddStfdd|DSdS)NT)Z_compared_to_operatorr6Z_compared_to_typeuniquecsg|]}j|ddqS)T)rIr6) _bind_param).0or)r@r6r-r. sz%array._bind_param..)rgetitemrrr4r1)r@r)rHr6rIr-rNr.rKs zarray._bind_paramzOptional[OperatorType]zUnion[Self, Grouping[_T]])againstr*cCs&|tjtjtjfkrt|S|SdSrD)rZany_opZall_oprPrr)r@rQr-r-r. self_groups zarray.self_group)NF)N)__name__ __module__ __qualname____doc__Z__visit_name__Zstringify_dialectrZdp_clauseelement_tupleZdp_typer5__annotations__r;propertyrFrKrR __classcell__r-r-rAr.r1Ls M #r1c@seZdZdZdddddddd ZGd d d ejjeZeZ e j dd d dZ dddddZ dddddZddddddZdS)r>an 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. FNz_TypeEngineArgument[_T]rGz Optional[int])r?as_tupler9 zero_indexescCs>t|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)r=r> ValueErrorr4r?rZr9r[)r@r?rZr9r[r-r-r.r;6s'  zARRAY.__init__c@sBeZdZdZddddddZddddd Zdddd 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&)r'kwargsr*cKs|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. Z result_type)operater r<Boolean)r@r'r]r-r-r.containsss zARRAY.Comparator.contains)r'r*cCs|jt|tjdS)zBoolean expression. Test if elements are a proper subset of the elements of the argument array expression. r^)r_r r<r`r@r'r-r-r. contained_by~s zARRAY.Comparator.contained_bycCs|jt|tjdS)zuBoolean expression. Test if array has elements in common with an argument array expression. r^)r_r r<r`rbr-r-r.overlapszARRAY.Comparator.overlapN)rSrTrUrVrarcrdr-r-r-r. Comparatoris  rerCcCst|jtjo|jjSrD)r=r?r<EnumZ native_enumrEr-r-r._against_native_enumszARRAY._against_native_enumrz#Optional[_LiteralProcessorType[_T]])dialectr*csJj||dkrdSddddddddfdd }|S) NzIterable[typing_Any]str)elementsr*cSsdd|dS)NzARRAY[z, ])join)rjr-r-r.to_strsz'ARRAY.literal_processor..to_strSequence[typing_Any]valuer*cs|j}|SrD)_apply_item_processorr9rpinner item_procr@rmr-r.processsz(ARRAY.literal_processor..process)r? dialect_implliteral_processorr@rhrvr-rtr.rxs zARRAY.literal_processorz2Optional[_BindProcessorType[Sequence[typing_Any]]]cs,j||dddfdd }|S)NOptional[Sequence[typing_Any]]zOptional[list[typing_Any]]rocs"|dkr |S|jtSdSrD)rqr9listrprur@r-r.rvsz%ARRAY.bind_processor..process)r?rwbind_processorryr-r}r.r~s   zARRAY.bind_processorobjectz*_ResultProcessorType[Sequence[typing_Any]])rhcoltyper*cslj|||dddfdd }jrh|tddddfd d dddfd d }|S) Nrnrzrocs,|dkr |S|jjr"tntSdSrD)rqr9rZtupler{r|r}r-r.rvs z'ARRAY.result_processor..processz^{(.*)}$riSequence[Optional[str]]cs|d}t|S)Nr )matchgroup_split_enum_valuesrr)patternr-r.handle_raw_stringsz1ARRAY.result_processor..handle_raw_stringcs&|dkr |St|tr |n|SrD)r=rir|)rsuper_rpr-r.rvs )r?rwresult_processorrgrecompile)r@rhrrvr-)rrurr@rr.rs   zARRAY.result_processor)FNF)rSrTrUrVr;r<r>rer$Zcomparator_factoryrZmemoized_propertyrgrxr~rr-r-r-r.r>sJ3#r>rir) array_stringr*cCsd|kr$dd|r|dngDS|dd}|dd}g}td |}d }|D]H}|dkrh| }qT|r||ddqT|d dtd |DqT|S) N"cSsg|]}|dkr|ndqSZNULLNr-rLrr-r-r.rOsz&_split_enum_values..,z\"z _$ESC_QUOTE$_z\\\z(")FcSsg|]}|dkr|ndqSrr-rr-r-r.rOsz ([^\s,]+),?)splitreplacerappendextendfindall)rtextresultZ on_quotesZ in_quotestokr-r-r.rs(    r)6 __future__rrtypingrr%rrrrrr rr r r rr<rsqlrZ sql.visitorsrZengine.interfacesrZ sql._typingrrZ sql.elementsrrZsql.expressionrZ sql.operatorsrZsql.selectablerZ sql.type_apirrrrr Z util.typingr!r"r$eqr0ZExpressionClauseListr1r>rr-r-r-r. sT                                 #|