o Rc+9@sddlZddlmZddlmZddlmZddlmZddlmZddlm Z ej fd d Z ej fd d Z Gd ddej ejZejddddZejddddZejddddZGdddejZddZdS)N)types)util) coercions) expression) operators)rolescC |||S)zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method. See that method for details. )anyotherZarrexproperatorrFD:\Flask\env\Lib\site-packages\sqlalchemy/dialects/postgresql/array.pyAny rcCr )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method. See that method for details. )allr rrrAllrrcsLeZdZdZdZdZdZfddZeddZ dd d Z dd d Z Z S)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:: 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:: 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` postgresqlTc sdd|D}tt|j|i|dd|D|_|d|jr%|jdntj}t|trBt|j |j dur;|j dndd|_ dSt||_ dS) NcSsg|] }ttj|qSr)rexpectrZExpressionElementRole).0crrr ]sz"array.__init__..cSsg|]}|jqSr)type)rargrrrrcstype_r) dimensions) superr__init__Z _type_tuplepopsqltypesZNULLTYPE isinstanceARRAY item_typerr)selfZclauseskwZ main_type __class__rrr!\s"   zarray.__init__cCs|fSNrr'rrr_select_iterableszarray._select_iterableFNcs@|stjurtjd|jddStfdd|DS)NT)Z_compared_to_operatorrZ_compared_to_typeuniquecsg|] }j|ddqS)T)_assume_scalarr) _bind_param)ror r'rrrrs z%array._bind_param..)rgetitemrZ BindParameterrr)r'r objr0rrr3rr1ws zarray._bind_paramcCs"|tjtjtjfvrt|S|Sr+)rZany_opZall_opr4rZGrouping)r'Zagainstrrr self_groups zarray.self_group)FNr+) __name__ __module__ __qualname____doc__Z__visit_name__Zstringify_dialectZ inherit_cacher!propertyr-r1r6 __classcell__rrr)rr$s1   rz@>T) precedenceZ is_comparisonz<@z&&c@seZdZdZGdddejjZeZ dddZe dd Z e d d Z d d Z ddZ ejddZddZddZddZdS)r%a PostgreSQL ARRAY type. .. versionchanged:: 1.1 The :class:`_postgresql.ARRAY` type is now a subclass of the core :class:`_types.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]) The :class:`_postgresql.ARRAY` type may not be supported on all PostgreSQL DBAPIs; it is currently known to work on psycopg2 only. 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. 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`. 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. Z result_type)operateCONTAINSr#Boolean)r'r kwargsrrrcontainsszARRAY.Comparator.containscCr?)zBoolean expression. Test if elements are a proper subset of the elements of the argument array expression. r@)rA CONTAINED_BYr#rCr'r rrr contained_byszARRAY.Comparator.contained_bycCr?)zuBoolean expression. Test if array has elements in common with an argument array expression. r@)rAOVERLAPr#rCrGrrroverlapszARRAY.Comparator.overlapN)r7r8r9r:rErHrJrrrr Comparators   rKFNcCs>t|tr tdt|tr|}||_||_||_||_dS)aPConstruct 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. .. versionadded:: 0.9.5 zUDo not nest ARRAY types; ARRAY(basetype) handles multi-dimensional arrays of basetypeN)r$r% ValueErrorrr&as_tupler zero_indexes)r'r&rMrrNrrrr!s &  zARRAY.__init__cCs|jSr+)rMr,rrrhashable8r.zARRAY.hashablecCstSr+)listr,rrr python_type<szARRAY.python_typecCs||kSr+r)r'xyrrrcompare_values@szARRAY.compare_valuescstdurt|}dksdur,|rt|dttfs,r(fdd|DS|Sfdd|DS)Nrrc3s|]}|VqdSr+rrrR)itemprocrr Rsz$ARRAY._proc_array..c3s0|]}|durdndVqdSNr) _proc_arrayrU collectiondimrVr'rrrWVs )rPr$tuple)r'ZarrrVr\r[rrZrrYCs  zARRAY._proc_arraycCst|jtjo |jjSr+)r$r&r#EnumZ native_enumr,rrr_against_native_enum`szARRAY._against_native_enumcCs|Sr+r)r'Z bindvaluerrrbind_expressiongszARRAY.bind_expressioncs$j||fdd}|S)Ncs|dur|S|jtSr+)rYrrPvalue item_procr'rrprocessos  z%ARRAY.bind_processor..process)r& dialect_implbind_processor)r'dialectrerrcrrgjs zARRAY.bind_processorcsTj|||fdd}jr(|tdfddfdd}|S)Ncs*|dur|S|jjrtStSr+)rYrrMr]rPrarcrrre~sz'ARRAY.result_processor..processz^{(.*)}$cs|d}t|SrX)matchgroup_split_enum_values)rbinner)patternrrhandle_raw_stringsz1ARRAY.result_processor..handle_raw_stringcs*|dur|St|tjr|S|Sr+)r$r string_typesra)rnsuper_rprrres )r&rfresult_processorr_recompile)r'rhZcoltyperer)rnrdrmr'rprrqys     zARRAY.result_processor)FNF)r7r8r9r:r#r%rKZcomparator_factoryr!r;rOrQrTrYrZmemoized_propertyr_r`rgrqrrrrr%s"F" 2    r%cCsd|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,]+),?)splitreplacerrappendextendfindall)Z array_stringtextresultZ on_quotesZ in_quotestokrrrrks   rk)rrrr#rsqlrrrreqrrZ ClauseListZ ColumnElementrZ custom_oprBrFrIr%rkrrrrs"        o