?????????? ????????? - ??????????????? - /home/agenciai/.local/lib/python3.9/site-packages/sqlalchemy/dialects/postgresql/__pycache__/array.cpython-39.pyc
???????
a ��JhZB � @ s� d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dlmZ d dlm Z d dlm Z d d lm Z d d l m Z d d l mZ d d l mZ ddlmZ ddlmZ ddlmZ ddlm Z ddlmZ e �rvddlmZ ddlmZ ddlm Z ddl m Z ddl m Z ddl m!Z! ddl"m#Z# ddl$m%Z% dd l&m'Z' dd l&m(Z( dd l&m)Z) dd l&m*Z* dd lm+Z+ dd!l,m-Z- e d"ed#�Z.e j/fd$d%d&d'd(�d)d*�Ze j/fd$d%d&d'd(�d+d,�Z0G d-d.� d.ej1e. �Z2G d/d0� d0ej3e. �Z3d1d2d3�d4d5�Z4dS )6� )� 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� typing_Anyz _ColumnExpressionArgument[_T]r �ColumnElement[bool])�other�arrexpr�operator�returnc C s |� | |�S )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method. See that method for details. )�any�r& r' r( � r, �Y/home/agenciai/.local/lib/python3.9/site-packages/sqlalchemy/dialects/postgresql/array.pyr 1 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 s� e Zd ZU dZd ZdZdejfdejfgZ de d< dd�d d d d �� fd d�Z e dd�dd��Z d dd dddd�dd�Zd!dd d �d d �Z� ZS )"�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: .. 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` Z postgresql�clauses�typer �_traverse_internalsN)�type_z Iterable[_T]z!Optional[_TypeEngineArgument[_T]]r$ )r1 r4 �kwc s~ t � jtjg|�R i |�� |dur(|n| jr:| jd jntj}t|t �rpt |j |j durd|j d ndd�| _n t |�| _dS )a Construct 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. Nr r � )� dimensions) �super�__init__r Zcomma_opr1 r2 �sqltypesZNULLTYPE� isinstance�ARRAY� item_typer7 )�selfr1 r4 r5 Z main_type�� __class__r, r- r9 � s �� � � zarray.__init__r �r) c C s | fS �Nr, �r> r, r, r- �_select_iterable� s zarray._select_iterableFr zOptional[TypeEngine[_T]]�boolzBindParameter[_T])r( �objr4 �_assume_scalarr) c sD |s� t ju r&tjd |� ��jdd�S t� ��fdd�|D ��S d S )NT)Z_compared_to_operatorr4 Z_compared_to_type�uniquec s g | ]}�j � |d �d��qS )T)rG r4 )� _bind_param)�.0�o�r( r> r4 r, r- � <listcomp>� s ��z%array._bind_param.<locals>.<listcomp>)r �getitemr r r2 r0 )r> r( rF r4 rG r, rL r- rI � s � ��zarray._bind_paramzOptional[OperatorType]zUnion[Self, Grouping[_T]])�againstr) c C s& |t jt jt jfv r t�| �S | S d S rB )r Zany_opZall_oprN r r )r> rO r, r, r- � self_group� s zarray.self_group)NF)N)�__name__� __module__� __qualname__�__doc__Z__visit_name__Zstringify_dialectr Zdp_clauseelement_tupleZdp_typer3 �__annotations__r9 �propertyrD rI rP � __classcell__r, r, r? r- r0 K s M� �# � �r0 c @ s� e Zd ZdZd ddddd�dd �ZG d d � d ejje �ZeZ e j dd �d d��Z ddd�dd�Z ddd�dd�Zdddd�dd�ZdS ) 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]rE z Optional[int])r= �as_tupler7 � 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< � ValueErrorr2 r= rX r7 rY )r> r= rX r7 rY r, r, r- r9 5 s ' � zARRAY.__init__c @ sB e Zd ZdZdddd�dd�Zddd�dd �Zddd�d 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) 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& r[ r, r, r- �containsr s zARRAY.Comparator.contains)r& r) c C s | j t|tjd�S )z�Boolean 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 �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. r\ )r] r r: r^ r` r, r, r- �overlap� s zARRAY.Comparator.overlapN)rQ rR rS rT r_ ra rb r, r, r, r- � Comparatorh s rc rA c C s t | jtj�o| jjS rB )r; r= r: �EnumZ native_enumrC r, r, r- �_against_native_enum� s �zARRAY._against_native_enumr z#Optional[_LiteralProcessorType[_T]])�dialectr) c sJ �j �|��|�� � d u r d S ddd�dd��ddd�� ��fdd � }|S ) NzIterable[typing_Any]�str)�elementsr) c S s dd� | �� d�S )NzARRAY[z, �])�join)rh r, r, r- �to_str� s z'ARRAY.literal_processor.<locals>.to_str�Sequence[typing_Any]��valuer) c s �� | � �j��}|S rB )�_apply_item_processorr7 �rn �inner�� item_procr> rk r, r- �process� s �z(ARRAY.literal_processor.<locals>.process)r= � dialect_impl�literal_processor�r> rf rt r, rr r- rv � s �zARRAY.literal_processorz2Optional[_BindProcessorType[Sequence[typing_Any]]]c s, �j �|��|�� ddd�� �fdd� }|S )N� Optional[Sequence[typing_Any]]zOptional[list[typing_Any]]rm c s" | d u r | S �� | � �jt�S d S rB )ro r7 �list�rn �rs r> r, r- rt � s �z%ARRAY.bind_processor.<locals>.process)r= ru �bind_processorrw r, r{ r- r| � s � zARRAY.bind_processor�objectz*_ResultProcessorType[Sequence[typing_Any]])rf �coltyper) c sl �j �|��||��ddd���fdd� }�jrh|�t�d��ddd��fd d � � ddd�� �fd d� }|S ) Nrl rx rm c s, | d u r | S �� | � �j�jr"tnt�S d S rB )ro r7 rX �tuplery rz r{ r, r- rt � s �z'ARRAY.result_processor.<locals>.processz^{(.*)}$rg � list[str]c s � � | ��d�}t|�S )Nr )�match�group�_split_enum_valuesrp )�patternr, r- �handle_raw_string� s z1ARRAY.result_processor.<locals>.handle_raw_stringc s& | d u r | S �t | t�r � | �n| �S rB )r; rg rz )r� �super_rpr, r- rt � s � �)r= ru �result_processorre �re�compile)r> rf r~ rt r, )r� rs r� r> r� r- r� � s � zARRAY.result_processor)FNF)rQ rR rS rT r9 r: r< rc r" Zcomparator_factoryr Zmemoized_propertyre rv r| r� r, r, r, r- r< � s J �3#r< rg r� )� array_stringr) c C s� d| vr| 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�replacer� �append�extend�findall)r� �text�resultZ on_quotesZ in_quotes�tokr, r, r- r� � s r� )5� __future__r r� �typingr r$ r r r r r r r r r r � r r: r Zsqlr Z sql.visitorsr Zengine.interfacesr Z sql._typingr r Z sql.elementsr r Zsql.expressionr Z sql.operatorsr Zsql.selectabler Z sql.type_apir r r r r Z util.typingr! r" �eqr/ ZExpressionClauseListr0 r< r� r, r, r, r- �<module> sR �� # |
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0 |
proxy
|
phpinfo
|
???????????