Wib-@ddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z dd lm Z dd lm Z dd lm Z dd lm Z d dlmZd dlmZdZGddejjZGddeZGddejZGddeZdS))ARRAY)array)ASTEXT) CONTAINED_BY)CONTAINS) DELETE_PATH)HAS_ALL)HAS_ANY)HAS_KEY)JSONPATH_ASTEXT) PATH_EXISTS) PATH_MATCH)types)cast)JSONJSONBc eZdZdZdZdZdS) JSONPathTypecfd}|S)Nct|tr|S|r,ddtt|z}nd}r |}|S)Nz{%s}z, z{}) isinstancestrjoinmap)value super_procs m/var/www/html/jarvis.com/web/backend/venv/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/json.pyprocessz(JSONPathType._processor..processsg%%%   $))CUOO"<"<= *" 5))L)selfdialectrrs ` r _processorzJSONPathType._processors#     r cT||||SN)r$string_bind_processorr"r#s rbind_processorzJSONPathType.bind_processor/s$w(B(B7(K(KLLLr cT||||Sr&)r$string_literal_processorr(s rliteral_processorzJSONPathType.literal_processor2s$w(E(Eg(N(NOOOr N)__name__ __module__ __qualname__r$r)r,r!r rrrsI$MMMPPPPPr rceZdZdZdZdS)JSONPATHadJSON 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 rr1r16s   NNNr r1czeZdZdZdZejZdfd ZGddej j Z e Z xZ S) ra 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 )``):: 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` TFNcbt|| ||_dSdS)aConstruct 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"r6r9 __class__s rr8z JSON.__init__s<( l333  "*D    # "r c(eZdZdZedZdS)JSON.Comparator6Define comparison operations for :class:`_types.JSON`.cJt|jjjtjjr;|jjt|jj|jj S|jjt|jj|jj S)aOn 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) rexprrighttypesqltypesrrleftoperater r9r)r"s rastextzJSON.Comparator.astexts$)/. 0JKK y~--#IO $ 5. y~--DIO9N.r N)r-r.r/r2propertyrGr!r r Comparatorr<s3DD       r rI)FN) r-r.r/r2render_bind_castrDTextr9r8rrIcomparator_factory __classcell__)r:s@rrrHsHHT(-//K++++++0X]-8$r rc@eZdZdZdZGddejZeZdS)ra 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` cBeZdZdZdZdZdZdZdZdZ dZ d Z d S) JSONB.Comparatorr=cP|t|tjS)zBoolean expression. Test for presence of a key (equivalent of the ``?`` operator). Note that the key may be a SQLA expression. r?)rFr rDBooleanr"others rhas_keyzJSONB.Comparator.has_key<<H`` operator). kwargs may be ignored by this operator but are required for API conformance. r?)rFrrDrR)r"rTkwargss rcontainszJSONB.Comparator.containss<<%X=M<NN Nr cP|t|tjS)zBoolean expression. Test if keys are a proper subset of the keys of the argument jsonb expression (equivalent of the ``<@`` operator). r?)rFrrDrRrSs r contained_byzJSONB.Comparator.contained_bys) <<e1A  r ct|tst|}t|ttj}|t|tS)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 r?) r _pg_arrayrrrDTEXTrFrr)r"r right_sides r delete_pathzJSONB.Comparator.delete_path(sTeY// )!%((eU8=%9%9::J<< ZU<KK Kr cP|t|tjS)zBoolean expression. Test for presence of item given by the argument JSONPath expression (equivalent of the ``@?`` operator). .. versionadded:: 2.0 r?)rFr rDrRrSs r path_existszJSONB.Comparator.path_exists6s) <<U0@  r cP|t|tjS)aBoolean 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 r?)rFrrDrRrSs r path_matchzJSONB.Comparator.path_match@s)<<Ex/?  r N) r-r.r/r2rUrXrZr]r_rdrfrhr!r rrIrPsDD N N N  N N N  N N N  O O O    L L L        r rIN)r-r.r/r2r3rrIrLr!r rrrs_..`NKKKKKT_KKKZ$r rN)rrra operatorsrrrrr r r r r rrrDsqlr__all__rrr1rr!r rrms%%%%%%######""""""&&&&&&""""""!!!!!!!!!!!! PPPPP8=-PPP4     |   $B$B$B$B$B$8=B$B$B$J@$@$@$@$@$D@$@$@$@$@$r