📁 File Manager Pro
v10.0.3 | PHP: 8.2.31
Server: LiteSpeed
2026-06-28 21:52:02
📂
/ (Root)
/
opt
/
hc_python
/
lib
/
python3.12
/
site-packages
/
sqlalchemy
/
dialects
/
postgresql
/
__pycache__
📍 /opt/hc_python/lib/python3.12/site-packages/sqlalchemy/dialects/postgresql/__pycache__
🔄 Refresh
✏️
Editing: array.cpython-312.pyc
Read Only
� S��g 6 � �L � 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 ede�� Zej( fd�Zej( fd�Z G d� dej, e � Z G d� de j0 � Zd� Zy)� )� annotationsN)�Any)�Optional)�TypeVar� )� CONTAINED_BY)�CONTAINS)�OVERLAP� )�types)�util)� expression)� operators)�_TypeEngineArgument�_T)�boundc �& � |j | |� S )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method. See that method for details. )�any��other�arrexpr�operators �U/opt/hc_python/lib64/python3.12/site-packages/sqlalchemy/dialects/postgresql/array.pyr r � � � �;�;�u�h� '�'� c �& � |j | |� S )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method. See that method for details. )�allr s r �Allr ' r r c �N � � e Zd ZdZd ZdZdZ� fd�Zed� � Z dd�Z d d�Z � xZ S ) �arraya0 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 ``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` � postgresqlTc �� �� |j dd � }t �| � t j g|��i |�� | j D �cg c] }|j �� c}| _ |�|n*| j r| j d nt j }t |t � r8t |j |j �|j dz nd�� | _ y t |� | _ y c c}w )N�type_r r � )� dimensions)�pop�super�__init__r �comma_op�clauses�type� _type_tuple�sqltypes�NULLTYPE� isinstance�ARRAY� item_typer% )�selfr* �kw�type_arg�arg� main_type� __class__s �r r( zarray.__init__n s� �� ��6�6�'�4�(�� ����+�+�<�g�<��<�04� � �=� ��C�H�H� �=��� �#� �(,�(8�(8��!�!�!�$�h�>O�>O� � �i�� '� ��#�#� !�+�+�7� �(�(�1�,�� �D�I� �i�(�D�I��% >s �C&c � � | fS �N� �r2 s r �_select_iterablezarray._select_iterable� s � ��w�r c �� � |s|t j u r%t j d |||| j d�� S t |D �cg c] }| j ||d|�� �� c}� S c c}w )NT)�_compared_to_operatorr# �_compared_to_type�unique)�_assume_scalarr# )r �getitemr � BindParameterr+ r � _bind_param)r2 r �objrA r# �os r rD zarray._bind_param� s� � � �X��):�):� :� �+�+���&.��"&�)�)�� � � � !� � !�� �$�$� �!�D�� %� � !� �� ��s � A&c � � |t j t j t j fv rt j | � S | S r9 )r �any_op�all_oprB r �Grouping)r2 �againsts r � self_groupzarray.self_group� s9 � � �y�'�'��)9�)9�9�;L�;L�M� M� �&�&�t�,� ,��Kr )FNr9 ) �__name__� __module__� __qualname__�__doc__�__visit_name__�stringify_dialect� inherit_cacher( �propertyr< rD rL � __classcell__)r7 s @r r r 0 s> �� �6�p �N�$���M�)�0 �� ���*r r c �� � e Zd ZdZ d dd�Z G d� dej j � ZeZe d� � Z e d� � Z d� Z e j d � � Zd � Zd � Zd � Zy)r0 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. Nc � � t |t � r t d� �t |t � r |� }|| _ || _ || _ || _ y)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/ r0 � ValueErrorr+ r1 �as_tupler% � zero_indexes)r2 r1 rY r% rZ s r r( zARRAY.__init__� sQ � �N �i�� '� �?�� � �i�� &�!� �I�"��� �� �$��� (��r c �" � e Zd ZdZd� Zd� Zd� Zy)�ARRAY.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 �N � | j t |t j �� 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. �� result_type)�operater r- �Boolean)r2 r �kwargss r �containszARRAY.Comparator.contains+ s � � �<�<��%�X�=M�=M�<�N� Nr c �N � | j t |t j �� S )z�Boolean expression. Test if elements are a proper subset of the elements of the argument array expression. r^ )r` r r- ra �r2 r s r � contained_byz ARRAY.Comparator.contained_by4 s' � � �<�<� �e��1A�1A� � � r c �N � | j t |t j �� S )zuBoolean expression. Test if array has elements in common with an argument array expression. r^ )r` r r- ra re s r �overlapzARRAY.Comparator.overlap< s � � �<�<���H�<L�<L�<�M� Mr N)rM rN rO rP rc rf rh r: r r � Comparatorr\ ! s � � � O� � Nr ri c � � | j S r9 )rY r; s r �hashablezARRAY.hashableD s � ��}�}� r c � � t S r9 )�listr; s r � python_typezARRAY.python_typeH s � �� r c � � ||k( S r9 r: )r2 �x�ys r �compare_valueszARRAY.compare_valuesL s � ��A�v� r c �z � t | j t j � xr | j j S r9 )r/ r1 r- �Enum� native_enumr; s r �_against_native_enumzARRAY._against_native_enumO s- � � �t�~�~�x�}�}� 5� +����*�*� r c �z � ��� � j j |� j |� ���y d� ��� �fd�}|S )Nc �, � ddj | � � d�S )NzARRAY[z, �])�join)�elementss r �to_strz'ARRAY.literal_processor.<locals>.to_str] s � ��D�I�I�h� /�0��2� 2r c �D �� �j | ��j �� }|S r9 )�_apply_item_processorr% )�value�inner� item_procr2 r| s ���r �processz(ARRAY.literal_processor.<locals>.process` s' �� ��.�.��y�$�/�/�6��E� �Lr )r1 � dialect_impl�literal_processor)r2 �dialectr� r� r| s ` @@r r� zARRAY.literal_processorV sA �� ��N�N�/�/��8�J�J� � � � � �� 3� � �r c �j � �� � j j |� j |� ��� fd�}|S )Nc �P �� | �| S �j | ��j t � S r9 )r~ r% rm �r r� r2 s ��r r� z%ARRAY.bind_processor.<locals>.processm s- �� ��}� � ��1�1��9�d�o�o�t�� r )r1 r� �bind_processor)r2 r� r� r� s ` @r r� zARRAY.bind_processorh s1 �� ��N�N�/�/��8�G�G� � � � � �r c �� � ����� � j j |� j ||� ��� fd�}� j r"|�t j d� ��fd����fd�}|S )Nc �| �� | �| S �j | ��j �j r t � S t � S r9 )r~ r% rY �tuplerm r� s ��r r� z'ARRAY.result_processor.<locals>.process| sE �� ��}� � ��1�1�� ��O�O� !�]�]�E� � � 15� � r z^{(.*)}$c �Z �� �j | � j d� }t |� S )Nr )�match�group�_split_enum_values)r r� �patterns �r �handle_raw_stringz1ARRAY.result_processor.<locals>.handle_raw_string� s' �� � � � �e�,�2�2�1�5��)�%�0�0r c �T �� | �| S �t | t � r �| � � S | � S r9 )r/ �str)r r� �super_rps ��r r� z'ARRAY.result_processor.<locals>.process� s? �� ��=� �L� �!�%��-� &�e�,�� � �� r )r1 r� �result_processorrv �re�compile)r2 r� �coltyper� r� r� r� r� s ` @@@@r r� zARRAY.result_processorw s[ �� ��N�N�/�/��8�I�I� �W� � � � � $� $� �H��j�j��-�G� 1� � �r )FNF)r1 z_TypeEngineArgument[Any]rY �boolr% z Optional[int]rZ r� )rM rN rO rP r( r- r0 ri �comparator_factoryrT rk rn rr r �memoized_propertyrv r� r� r� r: r r r0 r0 � s� � �E�T �$(� "� 1)�+�1)� �1)� "� 1)� � 1)�f N�X�^�^�.�.� N�B $�� � � � � �� ��� ��� � � � �$ � $r r0 c �f � d| vr| r| j d� S g S | j dd� }|j dd� }g }t j d|� }d}|D ]T }|dk( r| }� |r"|j |j dd� � �0|j t j d |� � �V |S ) N�"�,z\"z _$ESC_QUOTE$_z\\�\z(")Fz ([^\s,]+),?)�split�replacer� �append�extend�findall)� array_string�text�result� on_quotes� in_quotes�toks r r� r� � s� � � �,� �*6�|�!�!�#�&�>�B�>� � � ��� 7�D� �<�<��t� $�D� �F������&�I��I��� �#�:� %� �I� � �M�M�#�+�+�o�s�;� <� �M�M�"�*�*�^�S�9� :� � �Mr )� __future__r r� �typingr r r r r r r � r r- r �sqlr � sql._typingr r �eqr �ExpressionClauseListr r0 r� r: r r �<module>r� s� �� #� � � � � #� � � !� � � � .� �T�� �� "+� � � (� "+� � � (�s�J� +� +�B� /� s�lu�H�N�N� u�pr
💾 Save Changes
❌ Cancel