U
|
¸ý°d7 ã @ s d dl mZ d dlZd dlmZ d dlmZ d dlmZ ddlmZ ddlm
|
Z
|
dd l m Z dd
|
l m Z dd lmZ ed ed Ze jfddZe jfddZG dd de je Ze jddddZe jddddZe jddddZG dd de jZd d ZdS ) é )Ú annotationsN)ÚAny)ÚOptional)ÚTypeVaré )Útypes)Úutil)Ú
|
expression)Ú operators)Ú_TypeEngineArgumentÚ_T)Úboundc C s | | |¡S )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method.
|
See that method for details.
|
|
)Úany©ÚotherZarrexprÚoperator© r ú[d:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/dialects/postgresql/array.pyr s r c C s | | |¡S )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method.
|
See that method for details.
|
|
)Úallr r r r ÚAll$ s r c sL e Zd ZdZd ZdZdZ fddZedd Z dd
|
d Z
|
dd d Z Z S )Úarraya× A 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`
|
|
Z
|
postgresqlTc s | dd ¡}t jtjf|| dd | jD | _|d k r@|n| jrP| jd ntj}t |t
|
rt
|
|j |j d k rz|j d ndd| _ n
|
t
|
|| _ d S )NÚtype_c S s g | ]
|
}|j qS r )Útype)Ú.0Úargr r r Ú
|
<listcomp>j s z"array.__init__.<locals>.<listcomp>r é é )Ú
|
dimensions)ÚpopÚsuperÚ__init__r
|
Zcomma_opÚclausesZ _type_tupleÚsqltypesZNULLTYPEÚ
|
isinstanceÚARRAYÚ item_typer r )Úselfr" ÚkwZtype_argZ main_type©Ú __class__r r r! e s" ÿÿ û
|
ÿ ü
|
zarray.__init__c C s | fS ©Nr ©r' r r r Ú_select_iterable~ s zarray._select_iterableFNc sD |s t jkr&tjd | jddS t fdd|D S d S )NT)Z_compared_to_operatorr Z_compared_to_typeÚuniquec s g | ]}j |d dqS )T)Ú_assume_scalarr )Ú _bind_param)r Úo©r r' r r r r s ý ÿz%array._bind_param.<locals>.<listcomp>)r
|
Úgetitemr Z BindParameterr r )r' r Úobjr/ r r r2 r r0 s ú
|
üÿzarray._bind_paramc C s& |t jt jt jfkr t | ¡S | S d S r+ )r
|
Zany_opZall_opr3 r ZGrouping)r' Zagainstr r r Ú
|
self_group s
|
zarray.self_group)FN)N) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Z__visit_name__Zstringify_dialectZ inherit_cacher! Úpropertyr- r0 r5 Ú __classcell__r r r) r r - s 1
|
|
r z@>é T)Ú
|
precedenceZ is_comparisonz<@z&&c @ s e Zd ZdZG dd dejjZeZdddddd d
|
d Ze d d Z
|
e dd Z dd Z e jdd Zdd Zdd Zdd ZdS )r% aF
|
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])
|
|
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( e Zd ZdZdd Zdd Zdd ZdS ) 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`.
|
|
c K s | j t|tjdS )zåBoolean 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)ÚoperateÚCONTAINSr# ÚBoolean)r' r Úkwargsr r r Úcontainsô s zARRAY.Comparator.containsc C s | j t|tjdS )zBoolean expression. Test if elements are a proper subset of the
|
elements of the argument array expression.
|
r> )r? Ú CONTAINED_BYr# rA ©r' r r r r Ú contained_byý s
|
ÿz ARRAY.Comparator.contained_byc C s | j t|tjdS )zuBoolean expression. Test if array has elements in common with
|
an argument array expression.
|
r> )r? ÚOVERLAPr# rA rE r r r Úoverlap s zARRAY.Comparator.overlapN)r6 r7 r8 r9 rC rF rH r r r r Ú
|
Comparatoré s rI FNz_TypeEngineArgument[Any]Úboolz Optional[int])r& Úas_tupler Ú zero_indexesc C s> 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% Ú
|
ValueErrorr r& rK r rL )r' r& rK r rL r r r r! s '
|
ÿ
|
zARRAY.__init__c C s | j S r+ )rK r, r r r Úhashable@ s zARRAY.hashablec C s t S r+ )Úlistr, r r r Ú python_typeD s zARRAY.python_typec C s ||kS r+ r )r' ÚxÚyr r r Úcompare_valuesH s zARRAY.compare_valuesc C s t | jtjo| jjS r+ )r$ r& r# ÚEnumZ native_enumr, r r r Ú_against_native_enumK s þzARRAY._against_native_enumc s: j |¡ |¡ d kr d S dd fdd}|S )Nc S s dd | ¡ dS )NzARRAY[z, ú])Újoin)Úelementsr r r Úto_strY s z'ARRAY.literal_processor.<locals>.to_strc s | j¡}|S r+ )Ú_apply_item_processorr ©ÚvalueÚinner©Ú item_procr' rY r r Úprocess\ s ÿz(ARRAY.literal_processor.<locals>.process)r& Ú dialect_implÚliteral_processor©r' Údialectr` r r^ r rb R s ÿzARRAY.literal_processorc s$ j |¡ |¡ fdd}|S )Nc s" | d kr | S | jt¡S d S r+ )rZ r rO ©r\ ©r_ r' r r r` i s ÿz%ARRAY.bind_processor.<locals>.process)r& ra Úbind_processorrc r rf r rg d s
|
ÿzARRAY.bind_processorc sT j |¡ ||¡fdd}jrP|t d¡fdd fdd}|S )Nc s, | d kr | S | jjr"tnt¡S d S r+ )rZ r rK ÚtuplerO re rf r r r` x s üz'ARRAY.result_processor.<locals>.processz^{(.*)}$c s | ¡ d¡}t|S )Nr )ÚmatchÚgroupÚ_split_enum_valuesr[ )Úpatternr r Úhandle_raw_string s z1ARRAY.result_processor.<locals>.handle_raw_stringc s& | d kr | S t | tr | n| S r+ )r$ Ústrre )rm Úsuper_rpr r r` s ÿ
|
ý)r& ra Úresult_processorrU ÚreÚcompile)r' rd Zcoltyper` r )rm r_ rl r' ro r rp s s ÿ
|
zARRAY.result_processor)FNF)r6 r7 r8 r9 r# r% rI Zcomparator_factoryr! r: rN rP rS r Zmemoized_propertyrU rb rg rp r r r r r% ¥ s" C" û3
|
|
|
r% c C s d| kr| r| d¡S g S | dd¡}| dd¡}g }t d|¡}d}|D ]>}|dkr^| }qJ|rv| | dd¡¡ qJ| t d |¡¡ qJ|S )
|
Nú"ú,z\"z _$ESC_QUOTE$_z\\ú\z(")Fz ([^\s,]+),?)ÚsplitÚreplacerq ÚappendÚextendÚfindall)Z array_stringÚtextÚresultZ on_quotesZ in_quotesÚtokr r r rk s rk )Ú
|
__future__r rq Útypingr r r Ú r r# r Zsqlr r
|
Z sql._typingr r Úeqr ZExpressionClauseListr Z custom_opr@ rD rG r% rk r r r r Ú<module>
|
s& q v
|
