관리-도구
편집 파일: array.cpython-38.pyc
U -?�f�5 � @ s� d dl mZ d dlZd dlmZ d dlmZ d dlmZ ddlmZ ddlm Z dd lm Z d d l m Z d d l mZ d d lmZ d dlmZ d dlmZ eded�Zejfdd�Zejfdd�ZG dd� deje �ZG dd� de j�Zdd� ZdS ) � )� annotationsN)�Any)�Optional)�TypeVar� )� CONTAINED_BY)�CONTAINS)�OVERLAP� )�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 �T/opt/hc_python/lib64/python3.8/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� fdd�Zedd� �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` � postgresqlTc s� |� dd �}t� jtjf|�|� dd� | jD �| _|d k r@|n| jrP| jd ntj}t |t �r�t |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>k s z"array.__init__.<locals>.<listcomp>r 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% g s �� � � zarray.__init__c C s | fS �Nr �r+ r r r �_select_iterable s zarray._select_iterableFNc sD |s� t jkr&tjd |� ��jdd�S t� ��fdd�|D ��S d S )NT)Z_compared_to_operatorr Z_compared_to_type�uniquec s g | ]}�j � |d �d��qS )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 �objr3 r r r6 r r4 � s � ��zarray._bind_paramc C s& |t jt jt jfkr t�| �S | S d S r/ )r Zany_opZall_opr7 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% �propertyr1 r4 r9 � __classcell__r r r- r r 0 s 1 r c @ s� e Zd ZdZdddddd�dd �ZG d d � d ejj�ZeZe d d � �Z e dd� �Z dd� Z e jdd� �Zdd� Zdd� Zdd� ZdS )r) a[ 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_indexesc C s> t |t�rtd��t |t�r"|� }|| _|| _|| _|| _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* rA r" rB )r+ r* rA r" rB r r r r% � s ' � zARRAY.__init__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|tjd�S )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)�operater r' �Boolean)r+ r �kwargsr r r �contains! s zARRAY.Comparator.containsc C s | j t|tjd�S )z�Boolean expression. Test if elements are a proper subset of the elements of the argument array expression. rD )rE r r' rF �r+ r r r r � contained_by* s �z ARRAY.Comparator.contained_byc C s | j t|tjd�S )zuBoolean expression. Test if array has elements in common with an argument array expression. rD )rE r r' rF rI r r r �overlap2 s zARRAY.Comparator.overlapN)r: r; r< r= rH rJ rK r r r r � Comparator s rL c C s | j S r/ )rA r0 r r r �hashable: s zARRAY.hashablec C s t S r/ )�listr0 r r r � python_type> s zARRAY.python_typec C s ||kS r/ r )r+ �x�yr r r �compare_valuesB s zARRAY.compare_valuesc C s t | jtj�o| jjS r/ )r( r* r' �EnumZ native_enumr0 r r r �_against_native_enumE s �zARRAY._against_native_enumc s: �j �|��|�� � d kr d S dd� �� ��fdd�}|S )Nc S s dd� | �� d�S )NzARRAY[z, �])�join)�elementsr r r �to_strS s z'ARRAY.literal_processor.<locals>.to_strc s �� | � �j��}|S r/ )�_apply_item_processorr" ��value�inner�� item_procr+ rX r r �processV s �z(ARRAY.literal_processor.<locals>.process)r* � dialect_impl�literal_processor�r+ �dialectr_ r r] r ra L s �zARRAY.literal_processorc s$ �j �|��|�� � �fdd�}|S )Nc s" | d kr | S �� | � �jt�S d S r/ )rY r" rN �r[ �r^ r+ r r r_ c s �z%ARRAY.bind_processor.<locals>.process)r* r` �bind_processorrb r re r rf ^ s �zARRAY.bind_processorc sT �j �|��||����fdd�}�jrP|�t�d���fdd�� � �fdd�}|S )Nc s, | d kr | S �� | � �j�jr"tnt�S d S r/ )rY r" rA �tuplerN rd re r r r_ r s �z'ARRAY.result_processor.<locals>.processz^{(.*)}$c s � � | ��d�}t|�S )Nr )�match�group�_split_enum_valuesrZ )�patternr r �handle_raw_string� s z1ARRAY.result_processor.<locals>.handle_raw_stringc s& | d kr | S �t | t�r � | �n| �S r/ )r( �strrd )rl �super_rpr r r_ � s � �)r* r` �result_processorrT �re�compile)r+ rc Zcoltyper_ r )rl r^ rk r+ rn r ro m s � zARRAY.result_processor)FNF)r: r; r< r= r% r' r) rL Zcomparator_factoryr> rM rO rR r Zmemoized_propertyrT ra rf ro r r r r r) � s" G �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�replacerp �append�extend�findall)Z array_string�text�resultZ on_quotesZ in_quotes�tokr r r rj � s rj )� __future__r rp �typingr r r r r r r � r r' r �sqlr Z sql._typingr r �eqr ZExpressionClauseListr r) rj r r r r �<module> s& o v