📁 File Manager Pro
v10.0.3 | PHP: 8.2.31
Server: LiteSpeed
2026-06-28 11:18:27
📂
/ (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: ext.cpython-312.pyc
Read Only
� S��g�? � �� � d dl mZ d dlmZ d dlmZ d dlmZ ddlmZ ddlm Z dd l m Z dd l m Z dd l m Z dd l mZ dd l mZ ddl mZ ddlmZ ddlmZ ddlmZ ede�� ZerddlmZ G d� de j2 � Z G d� de� Zd� Z G d� dej: e � Z G d � d e � Z G d � d e � Z G d � d!e � Z! G d"� d#e � Z" G d$� d%e � Z# G d&� d'e � Z$y())� )� annotations)�Any)� TYPE_CHECKING)�TypeVar� )�types)�ARRAY� )� coercions)�elements)� expression)� functions)�roles)�schema)�ColumnCollectionConstraint)�TEXT)�InternalTraversal�_T)�bound)�_TraverseInternalsTypec � � e Zd ZU dZd ZdZdej fdej fdej fgZ de d< d� Z dd �Z d � Z ej fd �Zed � � Zy )�aggregate_order_bya Represent a PostgreSQL aggregate order by expression. E.g.:: from sqlalchemy.dialects.postgresql import aggregate_order_by expr = func.array_agg(aggregate_order_by(table.c.a, table.c.b.desc())) stmt = select(expr) would represent the expression: .. sourcecode:: sql SELECT array_agg(a ORDER BY b DESC) FROM table; Similarly:: expr = func.string_agg( table.c.a, aggregate_order_by(literal_column("','"), table.c.a) ) stmt = select(expr) Would represent: .. sourcecode:: sql SELECT string_agg(a, ',' ORDER BY a) FROM table; .. versionchanged:: 1.2.13 - the ORDER BY argument may be multiple terms .. seealso:: :class:`_functions.array_agg` � postgresql�target�type�order_byr �_traverse_internalsc �v � t j t j |� | _ | j j | _ t |� }|dk( r t d� �|dk( r-t j t j |d � | _ y t j |dt j i�| _ y )Nr z)at least one ORDER BY element is requiredr �_literal_as_text_role) r �expectr �ExpressionElementRoler r �len� TypeErrorr r � ClauseList)�selfr r �_lobs �S/opt/hc_python/lib64/python3.12/site-packages/sqlalchemy/dialects/postgresql/ext.py�__init__zaggregate_order_by.__init__N s� � � �&�&�u�'B�'B�F�K�� ��K�K�$�$�� ��8�}�� �1�9�� G�H� H� �Q�Y� %� ,� ,��+�+�X�a�[� �D�M� %� /� /�� �16�1L�1L� �D�M� Nc � � | S �N� )r% �againsts r' � self_groupz aggregate_order_by.self_group^ s � �� r) c �2 � | j | j fS r+ �r r )r% �kwargss r' � get_childrenz aggregate_order_by.get_childrena s � ��{�{�D�M�M�)�)r) c �d � || j fi |��| _ || j fi |��| _ y r+ r0 )r% �clone�kws r' �_copy_internalsz"aggregate_order_by._copy_internalsd s, � ��D�K�K�.�2�.�� � �d�m�m�2�r�2�� r) c �\ � | j j | j j z S r+ )r � _from_objectsr )r% s r' r8 z aggregate_order_by._from_objectsh s! � ��{�{�(�(�4�=�=�+F�+F�F�Fr) r+ )�__name__� __module__� __qualname__�__doc__�__visit_name__�stringify_dialectr �dp_clauseelement�dp_typer �__annotations__r( r. r2 r �_cloner6 �propertyr8 r, r) r' r r s� � �"�H *�N�$�� �$�5�5�6� �"�*�*�+� �&�7�7�8�3��/� � � �*� %-�O�O� 3� �G� �Gr) r c �n � � e Zd ZdZdZdZdZdZ ej ddd� d � � Z � fd �Z d d �Z � xZ S ) �ExcludeConstraintz�A table-level EXCLUDE constraint. Defines an EXCLUDE constraint as described in the `PostgreSQL documentation`__. __ https://www.postgresql.org/docs/current/static/sql-createtable.html#SQL-CREATETABLE-EXCLUDE �exclude_constraintNFr �wherez:class:`.ExcludeConstraint`z$:paramref:`.ExcludeConstraint.where`c � � g }g }i | _ t |� \ }}t t j t j |� |� D ]R \ \ }}} } } | �|j | � |� |j n| } | �| | j | < |j || | f� �T || _ t j | g|��|j d� |j d� |j d� d�� |j dd� | _ |j d� } | �)t j t j | � | _ |j d i � | _ y) a� Create an :class:`.ExcludeConstraint` object. E.g.:: const = ExcludeConstraint( (Column("period"), "&&"), (Column("group"), "="), where=(Column("group") != "some group"), ops={"group": "my_operator_class"}, ) The constraint is normally embedded into the :class:`_schema.Table` construct directly, or added later using :meth:`.append_constraint`:: some_table = Table( "some_table", metadata, Column("id", Integer, primary_key=True), Column("period", TSRANGE()), Column("group", String), ) some_table.append_constraint( ExcludeConstraint( (some_table.c.period, "&&"), (some_table.c.group, "="), where=some_table.c.group != "some group", name="some_table_excl_const", ops={"group": "my_operator_class"}, ) ) The exclude constraint defined in this example requires the ``btree_gist`` extension, that can be created using the command ``CREATE EXTENSION btree_gist;``. :param \*elements: A sequence of two tuples of the form ``(column, operator)`` where "column" is either a :class:`_schema.Column` object, or a SQL expression element (e.g. ``func.int8range(table.from, table.to)``) or the name of a column as string, and "operator" is a string containing the operator to use (e.g. `"&&"` or `"="`). In order to specify a column name when a :class:`_schema.Column` object is not available, while ensuring that any necessary quoting rules take effect, an ad-hoc :class:`_schema.Column` or :func:`_expression.column` object should be used. The ``column`` may also be a string SQL expression when passed as :func:`_expression.literal_column` or :func:`_expression.text` :param name: Optional, the in-database name of this constraint. :param deferrable: Optional bool. If set, emit DEFERRABLE or NOT DEFERRABLE when issuing DDL for this constraint. :param initially: Optional string. If set, emit INITIALLY <value> when issuing DDL for this constraint. :param using: Optional string. If set, emit USING <index_method> when issuing DDL for this constraint. Defaults to 'gist'. :param where: Optional SQL expression construct or literal SQL string. If set, emit WHERE <predicate> when issuing DDL for this constraint. :param ops: Optional dictionary. Used to define operator classes for the elements; works the same way as that of the :ref:`postgresql_ops <postgresql_operator_classes>` parameter specified to the :class:`_schema.Index` construct. .. versionadded:: 1.3.21 .. seealso:: :ref:`postgresql_operator_classes` - general description of how PostgreSQL operator classes are specified. N�name� deferrable� initially)rI rJ rK �using�gistrG �ops)� operators�zipr � expect_col_expression_collectionr �DDLConstraintColumnRole�appendrI � _render_exprsr r( �getrL r �StatementOptionRolerG rN )r% r r5 �columns� render_exprs� expressionsrO �expr�column�strname� add_element�operatorrI rG s r' r( zExcludeConstraint.__init__~ sL � �~ ��� ����!$�h� � � �Y�>A� � 6� 6��-�-�{� � � ? � :� 0�T�6�7�K�(� �&����{�+�"(�"4�6�;�;�'�D�� �'/����t�$� � � ��t�X� 6� 7� ? �" *���"�+�+� � � � � ���� ��v�v�l�+��f�f�[�)� � �V�V�G�V�,�� ����w��� � �"�)�)�%�*C�*C�U�K�D�J��6�6�%��$��r) c �� �� t �| � |� | j D ���cg c]* \ }}}t |t � s|n|j | ||f��, c}}}| _ y c c}}}w r+ )�super� _set_parentrT � isinstance�str�c)r% �tabler5 rZ rI r^ � __class__s �r' ra z ExcludeConstraint._set_parent sf �� � ���E�"� *.�);�);� � *<�$��d�H� '�t�S� 1��u�w�w�t�}��� � *<� ���� s �/Ac �r � | j D ���cg c]) \ }}}t j || j |� |f��+ }}}} | j || j | j | j | j | j d��}|j j | j � |S c c}}}w )N)rI rJ rK rG rL ) rT r �_copy_expression�parentrf rI rJ rK rG rL �dispatch�_update)r% � target_tabler5 rZ �_r^ r rd s r' �_copyzExcludeConstraint._copy s� � � &*�%7�%7� � &8�!��a�� �'�'��d�k�k�<�H�� � &8� � � �D�N�N� ��������n�n��*�*��*�*� �� � � ���4�=�=�)����! s �.B2r+ )r9 r: r; r< r= rG � inherit_cache� create_drop_stringify_dialectr �_document_text_coercionr( ra rn � __classcell__�rf s @r' rE rE m sT �� �� *�N� �E��M�$0�!�%�X�%�%��%�.�� %� � %�B �r) rE c �R � t |d< t j j | i |��S )z�PostgreSQL-specific form of :class:`_functions.array_agg`, ensures return type is :class:`_postgresql.ARRAY` and not the plain :class:`_types.ARRAY`, unless an explicit ``type_`` is passed. �_default_array_type)r r �func� array_agg)�argr5 s r' rw rw $ s) � � !&�B� � � �>�>� #� #�S� /�B� /�/r) c �" � � e Zd ZdZ� fd�Z� xZS )� _regconfig_fnTc � �� t |� }t |� dkD rTt j t j |j d� t | dd � | t j �� }|g}ng }|D �cg c]4 }t j t j |t | dd � | �� ��6 }}t �| �, ||z i |�� y c c}w )Nr r rI )rI �apply_propagate_attrs�type_�rI r| ) �listr" r r r r! �pop�getattrr � REGCONFIGr` r( )r% �argsr1 � initial_argrd � addtl_argsrf s �r' r( z_regconfig_fn.__init__2 s� �� ��D�z�� �t�9�q�=�#�*�*��+�+����� � �T�6�4�0�&*��o�o� �K� '�-�K� �K� � � �� � � ��+�+�� �T�6�4�0�&*� � � � � ���;��3�?��?�� s �59C)r9 r: r; ro r( rr rs s @r' rz rz / s �� ��M�@� @r) rz c �, � e Zd ZdZdZej Zy)� to_tsvectora� The PostgreSQL ``to_tsvector`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_postgresql.TSVECTOR`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.to_tsvector` will be used automatically when invoking ``sqlalchemy.func.to_tsvector()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 TN)r9 r: r; r< ro r �TSVECTORr r, r) r' r� r� L s � ��" �M� �>�>�Dr) r� c �, � e Zd ZdZdZej Zy)� to_tsquerya� The PostgreSQL ``to_tsquery`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_postgresql.TSQUERY`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.to_tsquery` will be used automatically when invoking ``sqlalchemy.func.to_tsquery()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 TN�r9 r: r; r< ro r �TSQUERYr r, r) r' r� r� b � � ��" �M� �=�=�Dr) r� c �, � e Zd ZdZdZej Zy)�plainto_tsquerya� The PostgreSQL ``plainto_tsquery`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_postgresql.TSQUERY`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.plainto_tsquery` will be used automatically when invoking ``sqlalchemy.func.plainto_tsquery()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 TNr� r, r) r' r� r� x r� r) r� c �, � e Zd ZdZdZej Zy)�phraseto_tsquerya� The PostgreSQL ``phraseto_tsquery`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_postgresql.TSQUERY`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.phraseto_tsquery` will be used automatically when invoking ``sqlalchemy.func.phraseto_tsquery()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 TNr� r, r) r' r� r� � r� r) r� c �, � e Zd ZdZdZej Zy)�websearch_to_tsquerya� The PostgreSQL ``websearch_to_tsquery`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_postgresql.TSQUERY`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.websearch_to_tsquery` will be used automatically when invoking ``sqlalchemy.func.websearch_to_tsquery()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 TNr� r, r) r' r� r� � r� r) r� c �* � � e Zd ZdZdZeZ� fd�Z� xZS )� ts_headlinea� The PostgreSQL ``ts_headline`` SQL function. This function applies automatic casting of the REGCONFIG argument to use the :class:`_postgresql.REGCONFIG` datatype automatically, and applies a return type of :class:`_types.TEXT`. Assuming the PostgreSQL dialect has been imported, either by invoking ``from sqlalchemy.dialects import postgresql``, or by creating a PostgreSQL engine using ``create_engine("postgresql...")``, :class:`_postgresql.ts_headline` will be used automatically when invoking ``sqlalchemy.func.ts_headline()``, ensuring the correct argument and return type handlers are used at compile and execution time. .. versionadded:: 2.0.0rc1 Tc �0 �� t |� }t |� dk rd}nKt |d t j � r,|d j j t j u rd}nd}|rTt j t j |j d� | t | dd � t j �� }|g}ng }|D �cg c]4 }t j t j |t | dd � | �� ��6 }}t! �| �D ||z i |�� y c c}w ) N� Fr Tr rI )r| rI r} r~ )r r" rb r � ColumnElementr �_type_affinityr r� r r r r! r� r� r� r` r( )r% r� r1 � has_regconfigr� rd r� rf s �r' r( zts_headline.__init__� s �� ��D�z�� �t�9�q�=� !�M� �t�A�w�� 6� 6� 7��Q�� � �+�+�u�}�}�<� "�M� �M� �#�*�*��+�+����� �&*� �T�6�4�0��o�o� �K� '�-�K� �K� � � �� � � ��+�+�� �T�6�4�0�&*� � � � � ���;��3�?��?�� s �9D) r9 r: r; r< ro r r r( rr rs s @r' r� r� � s �� ��" �M� �D�&@� &@r) r� N)%� __future__r �typingr r r � r �arrayr �sqlr r r r r r � sql.schemar � sql.sqltypesr � sql.visitorsr r r r� r rE rw �GenericFunctionrz r� r� r� r� r� r� r, r) r' �<module>r� s� �� #� � � � � � � � � � � � 4� � -� �T�� ���6�JG��1�1� JG�Zt�2� t�n0�@�I�-�-�b�1� @�:�-� �,� � �,�m� �,�}� �,�=� �,;@�-� ;@r)
💾 Save Changes
❌ Cancel