U
|
¸ý°d¨1 ã @ sJ d dl mZ d dl m Z ddlmZ ddlmZ ddlmZ dZ ej
|
ej Z ej de d d d
|
Zej d e d d d
|
Zej d e d d d
|
Zej d e d d d
|
Zej de d d d
|
Zej de d d d
|
Zej de d d d
|
Zej de d d d
|
Zej de d d d
|
Zej de d d d
|
ZG dd dejjZG dd deZG dd dejZG dd deZd S ) é )ÚARRAY)Úarrayé )Útypes)Úcast)Ú operators)ÚJSONÚJSONBz->>T)Ú
|
precedenceZnatural_self_precedentZeager_groupingz#>>ú?z?&z?|z@>z<@z#-z@?z@@c @ s$ e Zd Zdd Zdd Zdd ZdS )Ú JSONPathTypec s fdd}|S )Nc s< t | tr| S | r(dd tt| ¡ } nd} r8 | } | S )Nz{%s}z, z{})Ú
|
isinstanceÚstrÚjoinÚmap)Úvalue©Ú
|
super_proc© úZd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/dialects/postgresql/json.pyÚprocess_ s
|
z(JSONPathType._processor.<locals>.processr )ÚselfÚdialectr r r r r Ú
|
_processor^ s zJSONPathType._processorc C s | || |¡¡S ©N)r Zstring_bind_processor©r r r r r Úbind_processorp s zJSONPathType.bind_processorc C s | || |¡¡S r )r Zstring_literal_processorr r r r Úliteral_processors s z JSONPathType.literal_processorN)Ú__name__Ú
|
__module__Ú __qualname__r r r 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)r r r Ú__doc__Ú__visit_name__r r r r r! w s r! c sB e Zd ZdZe ¡ Zd fdd ZG dd dejj Z e Z
|
Z S ) 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`
|
|
FNc s t j|d |dk r || _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`.
|
|
)Ú none_as_nullN)ÚsuperÚ__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 | jjjtjjr0| jjjt | jj| jj
|
dS | jjjt | jj| jj
|
dS 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 r" Úpropertyr4 r r r r Ú
|
Comparatorî s r6 )FN) r r r r" r/ ÚTextr' r& r r6 Úcomparator_factoryÚ __classcell__r r r( r r s
|
J r c @ s* e Zd ZdZd ZG dd dejZeZdS )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 @ sP e Zd ZdZdd Zdd Zdd Zdd Zd
|
d Zd d Z dd Z
|
dd Z dS )zJSONB.Comparatorr* c C s | j t|tjdS )zvBoolean expression. Test for presence of a key. Note that the
|
key may be a SQLA expression.
|
r+ )r1 ÚHAS_KEYr/ ÚBoolean©r Úotherr r r Úhas_keyC s zJSONB.Comparator.has_keyc C s | j t|tjdS )z;Boolean expression. Test for presence of all keys in jsonbr+ )r1 ÚHAS_ALLr/ r; r< r r r Úhas_allI s zJSONB.Comparator.has_allc C s | j t|tjdS )z:Boolean expression. Test for presence of any key in jsonbr+ )r1 ÚHAS_ANYr/ r; r< r r r Úhas_anyM s zJSONB.Comparator.has_anyc K s | j t|tjdS )zòBoolean expression. Test if keys (or array) are a superset
|
of/contained the keys of the argument jsonb expression.
|
|
kwargs may be ignored by this operator but are required for API
|
conformance.
|
r+ )r1 ÚCONTAINSr/ r; )r r= Úkwargsr r r ÚcontainsQ s zJSONB.Comparator.containsc C s | j t|tjdS )z|Boolean expression. Test if keys are a proper subset of the
|
keys of the argument jsonb expression.
|
r+ )r1 Ú CONTAINED_BYr/ r; r< r r r Ú contained_byZ s
|
ÿz JSONB.Comparator.contained_byc C s2 t |tst|}t|ttj}| jt|tdS )a JSONB expression. Deletes field or array element specified in
|
the argument array.
|
|
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
|
r+ ) r Ú _pg_arrayr r r/ ZTEXTr1 Ú DELETE_PATHr )r r Z
|
right_sider r r Ú delete_pathb s
|
z JSONB.Comparator.delete_pathc C s | j t|tjdS )zBoolean expression. Test for presence of item given by the
|
argument JSONPath expression.
|
|
.. versionadded:: 2.0
|
r+ )r1 Ú PATH_EXISTSr/ r; r< r r r Ú path_existsp s
|
ÿz JSONB.Comparator.path_existsc C s | j t|tjdS )zãBoolean expression. Test if JSONPath predicate given by the
|
argument JSONPath expression matches.
|
|
Only the first item of the result is taken into account.
|
|
.. versionadded:: 2.0
|
r+ )r1 Ú
|
PATH_MATCHr/ r; r< r r r Ú
|
path_matchz s
|
ÿzJSONB.Comparator.path_matchN) r r r r" r> r@ rB rE rG rJ rL rN r r r r r6 @ s
|
r6 N)r r r r" r# r r6 r8 r r r r r s 0Fr N) r r rH Ú r r/ Zsqlr r Ú__all__Z _PRECEDENCEZjson_getitem_opZidx_precedenceZ custom_opr3 r2 r: r? rA rC rF rI rK rM r r r! r r r r r Ú<module>
|
s üüüüüüüüüü
|
