U ovg 6@sddlmZddlZddlmZddlmZddlmZddlmZddlm Z dd lm Z d d l m Z d d l mZd d lmZd dlmZd dlmZededZejfddZejfddZGdddejeZGddde jZddZdS)) annotationsN)Any)Optional)TypeVar) CONTAINED_BY)CONTAINS)OVERLAP)types)util) expression) operators)_TypeEngineArgument_T)boundcCs |||S)zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method. See that method for details. )anyotherZarrexproperatorrH/tmp/pip-unpacked-wheel-uqd9otp_/sqlalchemy/dialects/postgresql/array.pyrsrcCs |||S)zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method. See that method for details. )allrrrrAll'srcsLeZdZdZdZdZdZfddZeddZ dd d Z dd d Z Z S)arraya0A 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 ``type_`` keyword argument is passed:: array(["foo", "bar"], type_=CHAR) 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` Z postgresqlTc s|dd}tjtjf||dd|jD|_|dk r@|n|jrP|jdntj}t |t rt |j |j dk rz|j dndd|_ n t ||_ dS)Ntype_cSsg|] }|jqSr)type).0argrrr rsz"array.__init__..rr) dimensions)popsuper__init__rZcomma_opclausesZ _type_tuplesqltypesZNULLTYPE isinstanceARRAY item_typer!r)selfr%kwZtype_argZ main_type __class__rrr$ns    zarray.__init__cCs|fSNrr*rrr_select_iterableszarray._select_iterableFNcsD|stjkr&tjd|jddStfdd|DSdS)NT)Z_compared_to_operatorrZ_compared_to_typeuniquecsg|]}j|ddqS)T)_assume_scalarr) _bind_param)rorr*rrrrsz%array._bind_param..)rgetitemr Z BindParameterrr)r*robjr2rrr5rr3s zarray._bind_paramcCs&|tjtjtjfkrt|S|SdSr.)rZany_opZall_opr6r ZGrouping)r*Zagainstrrr self_groups zarray.self_group)FN)N) __name__ __module__ __qualname____doc__Z__visit_name__Zstringify_dialectZ inherit_cacher$propertyr0r3r8 __classcell__rrr,rr0s8   rc@seZdZdZdddddddd ZGd d d ejjZeZe d d Z e ddZ ddZ e jddZddZddZddZdS)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[Any]boolz Optional[int])r)as_tupler! 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( ValueErrorrr)r@r!rA)r*r)r@r!rArrrr$s'  zARRAY.__init__c@s(eZdZdZddZddZddZdS) 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`. 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)operaterr&Boolean)r*rkwargsrrrcontains+szARRAY.Comparator.containscCs|jt|tjdS)zBoolean expression. Test if elements are a proper subset of the elements of the argument array expression. rC)rDrr&rEr*rrrr contained_by4s zARRAY.Comparator.contained_bycCs|jt|tjdS)zuBoolean expression. Test if array has elements in common with an argument array expression. rC)rDr r&rErHrrroverlap<szARRAY.Comparator.overlapN)r9r:r;r<rGrIrJrrrr Comparator!s  rKcCs|jSr.)r@r/rrrhashableDszARRAY.hashablecCstSr.)listr/rrr python_typeHszARRAY.python_typecCs||kSr.r)r*xyrrrcompare_valuesLszARRAY.compare_valuescCst|jtjo|jjSr.)r'r)r&EnumZ native_enumr/rrr_against_native_enumOszARRAY._against_native_enumcs:j||dkrdSddfdd}|S)NcSsdd|dS)NzARRAY[z, ])join)elementsrrrto_str]sz'ARRAY.literal_processor..to_strcs|j}|Sr.)_apply_item_processorr!valueinner item_procr*rWrrprocess`sz(ARRAY.literal_processor..process)r) dialect_implliteral_processorr*dialectr^rr\rr`Vs zARRAY.literal_processorcs$j||fdd}|S)Ncs"|dkr |S|jtSdSr.)rXr!rMrZr]r*rrr^msz%ARRAY.bind_processor..process)r)r_bind_processorrarrdrrehs  zARRAY.bind_processorcsTj|||fdd}jrP|tdfddfdd}|S)Ncs,|dkr |S|jjr"tntSdSr.)rXr!r@tuplerMrcrdrrr^|s z'ARRAY.result_processor..processz^{(.*)}$cs|d}t|S)Nr)matchgroup_split_enum_valuesrY)patternrrhandle_raw_stringsz1ARRAY.result_processor..handle_raw_stringcs&|dkr |St|tr |n|Sr.)r'strrc)rksuper_rprrr^s )r)r_result_processorrSrecompile)r*rbZcoltyper^r)rkr]rjr*rmrrnws     zARRAY.result_processor)FNF)r9r:r;r<r$r&r(rKZcomparator_factoryr=rLrNrQr Zmemoized_propertyrSr`rernrrrrr(s"J3!   r(cCsd|kr|r|dSgS|dd}|dd}g}td|}d}|D]>}|dkr^| }qJ|rv||ddqJ|td |qJ|S) N",z\"z _$ESC_QUOTE$_z\\\z(")Fz ([^\s,]+),?)splitreplaceroappendextendfindall)Z array_stringtextresultZ on_quotesZ in_quotestokrrrris   ri) __future__rrotypingrrrrrrr r r&r Zsqlr Z sql._typingrreqrZExpressionClauseListrr(rirrrr s&               vy