Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/sqlalchemy/dialects/postgresql/__pycache__/json.cpython-39.pyc
Ðазад
a _�hw' � @ s� d dl mZ ddlmZ ddlmZ ddlmZ dZej ej Z ej de ddd �Z ej d e ddd �Zej d e ddd �Zej d e ddd �Zej d e ddd �Zej de ddd �Zej de ddd �ZG dd� dejj�ZG dd� dej�ZG dd� de�ZdS )� )�absolute_import� )�types)�util)� operators)�JSON�JSONBz->>T)� precedenceZnatural_self_precedentZeager_groupingz#>>�?z?&z?|z@>z<@c @ s e Zd Zdd� Zdd� ZdS )� JSONPathTypec s | � |�� � fdd�}|S )Nc s> t | tjj�sJ �dd� | D �}dd�|� } � r:� | �} | S )Nc S s g | ]}t �|��qS � �r � text_type��.0�elemr r ��/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/sqlalchemy/dialects/postgresql/json.py� <listcomp>K � z@JSONPathType.bind_processor.<locals>.process.<locals>.<listcomp>�{%s}�, �� isinstancer �collections_abc�Sequence�join��value�tokens�Z super_procr r �processI s z,JSONPathType.bind_processor.<locals>.process)Zstring_bind_processor��self�dialectr r r r �bind_processorF s zJSONPathType.bind_processorc s | � |�� � fdd�}|S )Nc s> t | tjj�sJ �dd� | D �}dd�|� } � r:� | �} | S )Nc S s g | ]}t �|��qS r r r r r r r X r zCJSONPathType.literal_processor.<locals>.process.<locals>.<listcomp>r r r r r r r r V s z/JSONPathType.literal_processor.<locals>.process)Zstring_literal_processorr! r r r �literal_processorS s z JSONPathType.literal_processorN)�__name__� __module__� __qualname__r$ r% r r r r r E s r c sB e Zd ZdZe�� Zd� fdd� ZG dd� dejj �Z e Z � Z 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 s$ t t| �j|d� |dur || _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" r) r, �� __class__r r r+ � s z JSON.__init__c @ s e Zd ZdZedd� �ZdS )zJSON.Comparator�6Define comparison operations for :class:`_types.JSON`.c C sP t | jjjtjj�r0| jjjt | jj| jj d�S | jjjt | jj| jj d�S dS )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` �Z result_typeN) r �expr�right�type�sqltypesr r �left�operate�JSONPATH_ASTEXTr, �ASTEXT)r" r r r �astext� s ��zJSON.Comparator.astextN)r& r' r( �__doc__�propertyr9 r r r r � Comparator� s r< )FN) r& r' r( r: r4 �Textr, r+ r r< �comparator_factory� __classcell__r r r- r r a s J r c @ s* e Zd ZdZd ZG dd� 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 @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) zJSONB.Comparatorr/ c C s | j t|tjd�S )zvBoolean expression. Test for presence of a key. Note that the key may be a SQLA expression. r0 )r6 �HAS_KEYr4 �Boolean�r" �otherr r r �has_key s zJSONB.Comparator.has_keyc C s | j t|tjd�S )z;Boolean expression. Test for presence of all keys in jsonbr0 )r6 �HAS_ALLr4 rA rB r r r �has_all% s zJSONB.Comparator.has_allc C s | j t|tjd�S )z:Boolean expression. Test for presence of any key in jsonbr0 )r6 �HAS_ANYr4 rA rB r r r �has_any) s zJSONB.Comparator.has_anyc K s | j t|tjd�S )z�Boolean expression. Test if keys (or array) are a superset of/contained the keys of the argument jsonb expression. r0 )r6 �CONTAINSr4 rA )r" rC �kwargsr r r �contains- s zJSONB.Comparator.containsc C s | j t|tjd�S )z|Boolean expression. Test if keys are a proper subset of the keys of the argument jsonb expression. r0 )r6 � CONTAINED_BYr4 rA rB r r r � contained_by3 s �z JSONB.Comparator.contained_byN) r& r' r( r: rD rF rH rK rM r r r r r< s r< N)r& r' r( r: Z__visit_name__r r< r> r r r r r � s / r N)� __future__r � r r4 r �sqlr �__all__Z _PRECEDENCEZjson_getitem_opZidx_precedenceZ custom_opr8 r7 r@ rE rG rI rL r r r r r r r �<module> sf �������
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0.01 |
proxy
|
phpinfo
|
ÐаÑтройка