File manager - Edit - /opt/cloudlinux/venv/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/json.cpython-311.pyc
Back
� �|oiw' � �� � d dl mZ ddlmZ ddlmZ ddlmZ dZej ej Z ej de dd� � � Z ej d e dd� � � Z ej d e dd� � � Z ej d e dd� � � Z ej d e dd� � � Z ej de dd� � � Z ej de dd� � � Z G d� dej j � � Z G d� dej � � Z G d� de� � ZdS )� )�absolute_import� )�types)�util)� operators)�JSON�JSONBz->>T)� precedence�natural_self_precedent�eager_groupingz#>>�?z?&z?|z@>z<@c � � e Zd Zd� Zd� ZdS )� JSONPathTypec �< �� | � |� � ��fd�}|S )Nc � �� t | t j j � � sJ �d� | D � � }dd� |� � z } �r �| � � } | S )Nc �6 � g | ]}t j |� � ��S � �r � text_type��.0�elems �Z/opt/cloudlinux/venv/lib64/python3.11/site-packages/sqlalchemy/dialects/postgresql/json.py� <listcomp>z@JSONPathType.bind_processor.<locals>.process.<locals>.<listcomp>K �" � �=�=�=�t�d�n�T�*�*�=�=�=� �{%s}�, �� isinstancer �collections_abc�Sequence�join��value�tokens� super_procs �r �processz,JSONPathType.bind_processor.<locals>.processI �d �� � �e�T�%9�%B�C�C� C� C�C�=�=�u�=�=�=�F��d�i�i�� /� /�0�E�� *�"� �5�)�)���Lr )�string_bind_processor��self�dialectr( r' s @r �bind_processorzJSONPathType.bind_processorF s6 �� ��/�/��8�8� � � � � � � �r c �< �� | � |� � ��fd�}|S )Nc � �� t | t j j � � sJ �d� | D � � }dd� |� � z } �r �| � � } | S )Nc �6 � g | ]}t j |� � ��S r r r s r r zCJSONPathType.literal_processor.<locals>.process.<locals>.<listcomp>X r r r r r r$ s �r r( z/JSONPathType.literal_processor.<locals>.processV r) r )�string_literal_processorr+ s @r �literal_processorz JSONPathType.literal_processorS s6 �� ��2�2�7�;�;� � � � � � � �r N)�__name__� __module__� __qualname__r. r3 r r r r r E s2 � � � � � � � � � � � � � r r c �v � � e Zd ZdZ ej � � Zd� fd� Z G d� dej j � � Z e Z � xZ S )r aB Represent the PostgreSQL JSON type. This type is a specialization of the Core-level :class:`_types.JSON` type. Be sure to read the documentation for :class:`_types.JSON` for important tips regarding treatment of NULL values and ORM use. .. versionchanged:: 1.1 :class:`_postgresql.JSON` is now a PostgreSQL- specific specialization of the new :class:`_types.JSON` type. The operators provided by the PostgreSQL version of :class:`_types.JSON` include: * Index operations (the ``->`` operator):: data_table.c.data['some key'] data_table.c.data[5] * Index operations returning text (the ``->>`` operator):: data_table.c.data['some key'].astext == 'some value' Note that equivalent functionality is available via the :attr:`.JSON.Comparator.as_string` accessor. * Index operations with CAST (equivalent to ``CAST(col ->> ['some key'] AS <type>)``):: data_table.c.data['some key'].astext.cast(Integer) == 5 Note that equivalent functionality is available via the :attr:`.JSON.Comparator.as_integer` and similar accessors. * Path index operations (the ``#>`` operator):: data_table.c.data[('key_1', 'key_2', 5, ..., 'key_n')] * Path index operations returning text (the ``#>>`` operator):: data_table.c.data[('key_1', 'key_2', 5, ..., 'key_n')].astext == 'some value' .. versionchanged:: 1.1 The :meth:`_expression.ColumnElement.cast` operator on JSON objects now requires that the :attr:`.JSON.Comparator.astext` modifier be called explicitly, if the cast works only from a textual string. Index operations return an expression object whose type defaults to :class:`_types.JSON` by default, so that further JSON-oriented instructions may be called upon the result type. Custom serializers and deserializers are specified at the dialect level, that is using :func:`_sa.create_engine`. The reason for this is that when using psycopg2, the DBAPI only allows serializers at the per-cursor or per-connection level. E.g.:: engine = create_engine("postgresql://scott:tiger@localhost/test", json_serializer=my_serialize_fn, json_deserializer=my_deserialize_fn ) When using the psycopg2 dialect, the json_deserializer is registered against the database using ``psycopg2.extras.register_default_json``. .. seealso:: :class:`_types.JSON` - Core level JSON type :class:`_postgresql.JSONB` FNc �p �� t t | � � � |�� � |� || _ dS dS )a+ Construct a :class:`_types.JSON` type. :param none_as_null: if True, persist the value ``None`` as a SQL NULL value, not the JSON encoding of ``null``. Note that when this flag is False, the :func:`.null` construct can still be used to persist a NULL value:: from sqlalchemy import null conn.execute(table.insert(), data=null()) .. versionchanged:: 0.9.8 - Added ``none_as_null``, and :func:`.null` is now supported in order to persist a NULL value. .. seealso:: :attr:`_types.JSON.NULL` :param astext_type: the type to use for the :attr:`.JSON.Comparator.astext` accessor on indexed attributes. Defaults to :class:`_types.Text`. .. versionadded:: 1.1 )� none_as_nullN)�superr �__init__� astext_type)r, r9 r< � __class__s �r r; z JSON.__init__� sB �� �2 �d�D���"�"� �"�=�=�=� � "� *�D� � � � #� "r c �( � e Zd ZdZed� � � ZdS )�JSON.Comparator�6Define comparison operations for :class:`_types.JSON`.c �J � t | j j j t j j � � r;| j j � t | j j | j j �� � S | j j � t | j j | j j �� � S )a On an indexed expression, use the "astext" (e.g. "->>") conversion when rendered in SQL. E.g.:: select([data_table.c.data['some key'].astext]) .. seealso:: :meth:`_expression.ColumnElement.cast` �� result_type) r �expr�right�type�sqltypesr r �left�operate�JSONPATH_ASTEXTr< �ASTEXT)r, s r �astextzJSON.Comparator.astext� s� � � �$�)�/�.�� �0J�K�K� ��y�~�-�-�#��I�O� $� � 5� .� � � � �y�~�-�-��D�I�O���9N� .� � � r N)r4 r5 r6 �__doc__�propertyrL r r r � Comparatorr? � s3 � � � � � �D�D� � � � �� � � r rO )FN) r4 r5 r6 rM rG �Textr< r; r rO �comparator_factory� __classcell__)r= s @r r r a s� �� � � � � �H� H�T �(�-�/�/�K�+� +� +� +� +� +�:� � � � �X�]�-� � � �8 $�����r r c �@ � e Zd ZdZd Z G d� dej � � ZeZdS )r a� Represent the PostgreSQL JSONB type. The :class:`_postgresql.JSONB` type stores arbitrary JSONB format data, e.g.:: data_table = Table('data_table', metadata, Column('id', Integer, primary_key=True), Column('data', JSONB) ) with engine.connect() as conn: conn.execute( data_table.insert(), data = {"key1": "value1", "key2": "value2"} ) The :class:`_postgresql.JSONB` type includes all operations provided by :class:`_types.JSON`, including the same behaviors for indexing operations. It also adds additional operators specific to JSONB, including :meth:`.JSONB.Comparator.has_key`, :meth:`.JSONB.Comparator.has_all`, :meth:`.JSONB.Comparator.has_any`, :meth:`.JSONB.Comparator.contains`, and :meth:`.JSONB.Comparator.contained_by`. Like the :class:`_types.JSON` type, the :class:`_postgresql.JSONB` type does not detect in-place changes when used with the ORM, unless the :mod:`sqlalchemy.ext.mutable` extension is used. Custom serializers and deserializers are shared with the :class:`_types.JSON` class, using the ``json_serializer`` and ``json_deserializer`` keyword arguments. These must be specified at the dialect level using :func:`_sa.create_engine`. When using psycopg2, the serializers are associated with the jsonb type using ``psycopg2.extras.register_default_jsonb`` on a per-connection basis, in the same way that ``psycopg2.extras.register_default_json`` is used to register these handlers with the json type. .. versionadded:: 0.9.7 .. seealso:: :class:`_types.JSON` c �0 � e Zd ZdZd� Zd� Zd� Zd� Zd� ZdS )�JSONB.Comparatorr@ c �P � | � t |t j �� � S )zvBoolean expression. Test for presence of a key. Note that the key may be a SQLA expression. rB )rI �HAS_KEYrG �Boolean�r, �others r �has_keyzJSONB.Comparator.has_key s � � �<�<���H�<L�<�M�M� Mr c �P � | � t |t j �� � S )z;Boolean expression. Test for presence of all keys in jsonbrB )rI �HAS_ALLrG rX rY s r �has_allzJSONB.Comparator.has_all% � � ��<�<���H�<L�<�M�M� Mr c �P � | � t |t j �� � S )z:Boolean expression. Test for presence of any key in jsonbrB )rI �HAS_ANYrG rX rY s r �has_anyzJSONB.Comparator.has_any) r_ r c �P � | � t |t j �� � S )z�Boolean expression. Test if keys (or array) are a superset of/contained the keys of the argument jsonb expression. rB )rI �CONTAINSrG rX )r, rZ �kwargss r �containszJSONB.Comparator.contains- s � � �<�<��%�X�=M�<�N�N� Nr c �P � | � t |t j �� � S )z|Boolean expression. Test if keys are a proper subset of the keys of the argument jsonb expression. rB )rI � CONTAINED_BYrG rX rY s r � contained_byz JSONB.Comparator.contained_by3 s) � � �<�<� �e��1A� � � � r N) r4 r5 r6 rM r[ r^ rb rf ri r r r rO rU sq � � � � � �D�D� N� N� N� N� N� N� N� N� N� O� O� O� � � � � r rO N)r4 r5 r6 rM �__visit_name__r rO rQ r r r r r � sV � � � � � �-� -�^ �N� � � � � �T�_� � � �> $���r r N)� __future__r � r rG r �sqlr �__all__� _PRECEDENCE�json_getitem_op�idx_precedence� custom_oprK rJ rW r] ra rd rh r r r r r r �<module>rs s �� '� &� &� &� &� &� !� !� !� !� !� !� � � � � � � � � � � � � ���&�y�'@�A�� �� � � � �� � � �� &�)�%� � � �� � � �� �)� �� � �� � � �� �)� �� � �� � � �� �)� �� � �� � � �� �9� �� � �� � � �� #�y�"�� � �� � � � �� � � � �8�=�-� � � �8F$� F$� F$� F$� F$�8�=� F$� F$� F$�RQ$� Q$� Q$� Q$� Q$�D� Q$� Q$� Q$� Q$� Q$r
| ver. 1.4 |
Github
|
.
| PHP 8.2.30 | Generation time: 0 |
proxy
|
phpinfo
|
Settings