?????????? ????????? - ??????????????? - /home/agenciai/.local/lib/python3.9/site-packages/sqlalchemy/dialects/postgresql/__pycache__/json.cpython-39.pyc
???????
a ��Jh*2 � @ s� d dl mZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ dd l m Z dd l m Z dd l m Z dd l mZ dd l mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddlmZ ddlmZ ddl m Z e�rJddl m Z ddl m!Z! ddl"m#Z# dd l"m$Z$ dd l"m%Z% d Z&G d d � d ej'j(�Z(G d!d"� d"e(�Z)G d#d$� d$ej'�Z'G d%d&� d&e'�Z*d'S )(� )� annotations)�Any)�Callable)�List)�Optional)� TYPE_CHECKING)�Union� )�ARRAY)�array)�ASTEXT)� CONTAINED_BY)�CONTAINS)� DELETE_PATH)�HAS_ALL)�HAS_ANY)�HAS_KEY)�JSONPATH_ASTEXT)� PATH_EXISTS)� PATH_MATCH� )�types)�cast)�_T)�Dialect)� ColumnElement)�_BindProcessorType)�_LiteralProcessorType)� TypeEngine)�JSON�JSONBc @ s> e Zd Zdddd�dd�Zddd�d d �Zdd d�d d �ZdS )� JSONPathTyper z Optional[Callable[[Any], Any]]zCallable[[Any], Any])�dialect� super_proc�returnc s ddd�� fdd� }|S )Nr )�valuer$ c s< t | t�r| S | r(dd�tt| �� } nd} � r8� | �} | S )Nz{%s}z, z{})� isinstance�str�join�map)r% �r# � �X/home/agenciai/.local/lib/python3.9/site-packages/sqlalchemy/dialects/postgresql/json.py�process/ s z(JSONPathType._processor.<locals>.processr+ )�selfr" r# r- r+ r* r, � _processor, s zJSONPathType._processorz_BindProcessorType[Any])r" r$ c C s | � || �|��S �N)r/ Zstring_bind_processor�r. r" r+ r+ r, �bind_processor@ s zJSONPathType.bind_processorz_LiteralProcessorType[Any]c C s | � || �|��S r0 )r/ Zstring_literal_processorr1 r+ r+ r, �literal_processorC s z JSONPathType.literal_processorN)�__name__� __module__� __qualname__r/ r2 r3 r+ r+ r+ r, r! + s r! c @ s e Zd ZdZd ZdS )�JSONPATHad JSON Path Type. This is usually required to cast literal values to json path when using json search like function, such as ``jsonb_path_query_array`` or ``jsonb_path_exists``:: stmt = sa.select( sa.func.jsonb_path_query_array( table.c.jsonb_col, cast("$.address.id", JSONPATH) ) ) N)r4 r5 r6 �__doc__�__visit_name__r+ r+ r+ r, r7 I s r7 c s\ e Zd ZU dZdZe�� Zded< dddd �� fd d � Z G d d � d ej j e �Z e Z � ZS )r a Represent the PostgreSQL JSON type. :class:`_postgresql.JSON` is used automatically whenever the base :class:`_types.JSON` datatype is used against a PostgreSQL backend, however base :class:`_types.JSON` datatype does not provide Python accessors for PostgreSQL-specific comparison methods such as :meth:`_postgresql.JSON.Comparator.astext`; additionally, to use PostgreSQL ``JSONB``, the :class:`_postgresql.JSONB` datatype should be used explicitly. .. seealso:: :class:`_types.JSON` - main documentation for the generic cross-platform JSON datatype. 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" 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+psycopg2://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` TzTypeEngine[str]� astext_typeFN�boolzOptional[TypeEngine[str]])� none_as_nullr: c s 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()}) .. 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`. )r< N)�super�__init__r: )r. r< r: �� __class__r+ r, r> � s z JSON.__init__c @ s, e Zd ZU dZded< edd�dd��ZdS ) zJSON.Comparator�6Define comparison operations for :class:`_types.JSON`.r �typezColumnElement[str])r$ 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�rightrB �sqltypesr r! �left�operater r: r )r. r+ r+ r, �astext� s ��zJSON.Comparator.astextN)r4 r5 r6 r8 �__annotations__�propertyrI r+ r+ r+ r, � Comparator� s rL )FN)r4 r5 r6 r8 Zrender_bind_castrF �Textr: rJ r> r rL r �comparator_factory� __classcell__r+ r+ r? r, r [ s M � r c @ s. e Zd ZdZd ZG dd� deje �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`, :meth:`.JSONB.Comparator.contained_by`, :meth:`.JSONB.Comparator.delete_path`, :meth:`.JSONB.Comparator.path_exists` and :meth:`.JSONB.Comparator.path_match`. 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. .. seealso:: :class:`_types.JSON` c @ s� e Zd ZU dZded< ddd�dd�Zddd�d d �Zddd�d d �Zdddd �dd�Zddd�dd�Z ddd�dd�Z ddd�dd�Z ddd�dd�Z dS ) zJSONB.ComparatorrA r rB r zColumnElement[bool])�otherr$ c C s | j t|tjd�S )z�Boolean expression. Test for presence of a key (equivalent of the ``?`` operator). Note that the key may be a SQLA expression. rC )rH r rF �Boolean�r. rP r+ r+ r, �has_key# s zJSONB.Comparator.has_keyc C s | j t|tjd�S )zxBoolean expression. Test for presence of all keys in jsonb (equivalent of the ``?&`` operator) rC )rH r rF rQ rR r+ r+ r, �has_all) s zJSONB.Comparator.has_allc C s | j t|tjd�S )zwBoolean expression. Test for presence of any key in jsonb (equivalent of the ``?|`` operator) rC )rH r rF rQ rR r+ r+ r, �has_any/ s zJSONB.Comparator.has_any)rP �kwargsr$ c K s | j t|tjd�S )a" Boolean expression. Test if keys (or array) are a superset of/contained the keys of the argument jsonb expression (equivalent of the ``@>`` operator). kwargs may be ignored by this operator but are required for API conformance. rC )rH r rF rQ )r. rP rV r+ r+ r, �contains5 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 (equivalent of the ``<@`` operator). rC )rH r rF rQ rR r+ r+ r, � contained_by? s �z JSONB.Comparator.contained_byz Union[List[str], _pg_array[str]]zColumnElement[JSONB])r r$ c C s2 t |t�st|�}t|ttj��}| jt|td�S )a= JSONB expression. Deletes field or array element specified in the argument array (equivalent of the ``#-`` operator). The input may be a list of strings that will be coerced to an ``ARRAY`` or an instance of :meth:`_postgres.array`. .. versionadded:: 2.0 rC ) r& � _pg_arrayr r rF ZTEXTrH r r )r. r Z right_sider+ r+ r, � delete_pathH s z JSONB.Comparator.delete_pathc C s | j t|tjd�S )z�Boolean expression. Test for presence of item given by the argument JSONPath expression (equivalent of the ``@?`` operator). .. versionadded:: 2.0 rC )rH r rF rQ rR r+ r+ r, � path_existsX s �z JSONB.Comparator.path_existsc C s | j t|tjd�S )a Boolean expression. Test if JSONPath predicate given by the argument JSONPath expression matches (equivalent of the ``@@`` operator). Only the first item of the result is taken into account. .. versionadded:: 2.0 rC )rH r rF rQ rR r+ r+ r, � path_matchb s �zJSONB.Comparator.path_matchN) r4 r5 r6 r8 rJ rS rT rU rW rX rZ r[ r\ r+ r+ r+ r, rL s rL N) r4 r5 r6 r8 r9 r rL r rN r+ r+ r+ r, r � s 1Qr N)+� __future__r �typingr r r r r r r r rY � operatorsr r r r r r r r r r � r rF Zsqlr Z sql._typingr Zengine.interfacesr Z sql.elementsr Z sql.type_apir r r �__all__r r! r7 r r+ r+ r+ r, �<module> sB
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0 |
proxy
|
phpinfo
|
???????????