,h*2SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SS K J r SS K J r SS K J r SS K Jr SS K Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSKJr SSKJr SSKJr \(aSSKJr SSK J!r! SSK"J#r# SSK"J$r$ SSK"J%r% Sr&"SS \RNRP5r("S!S"\(5r)"S#S$\RN5r'"S%S&\'5r*g')() 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)JSONJSONBcF\rSrSrSSjrSSjrS SjrSrg) JSONPathType+c^SU4SjjnU$)Nc>[U[5(aU$U(a#SSR[[U55-nOSnT(aT"U5nU$)Nz{%s}z, z{}) isinstancestrjoinmap)value super_procs [/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/dialects/postgresql/json.pyprocess(JSONPathType._processor..process/sL%%% $))CUO"<="5)L)r+rreturnr)selfdialectr,r.s ` r- _processorJSONPathType._processor,s r0cBURXRU55$N)r5string_bind_processorr3r4s r-bind_processorJSONPathType.bind_processor@sw(B(B7(KLLr0cBURXRU55$r8)r5string_literal_processorr:s r-literal_processorJSONPathType.literal_processorCsw(E(Eg(NOOr0r2N)r4rr,zOptional[Callable[[Any], Any]]r1zCallable[[Any], Any])r4rr1z_BindProcessorType[Any])r4rr1z_LiteralProcessorType[Any])__name__ __module__ __qualname____firstlineno__r5r;r?__static_attributes__r2r0r-r#r#+s=,J (MPP #Pr0r#c\rSrSrSrSrSrg)JSONPATHIa@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) ) ) r2N)rArBrCrD__doc____visit_name__rEr2r0r-rGrGIs  Nr0rGc^\rSrSr%SrSr\R"5rS\ S'S S U4Sjjjr "SS\RR\ 5r \ rS rU=r$) r [aB 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` TzTypeEngine[str] astext_typec4>[TU]US9 UbX lgg)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__rM)r3rOrM __class__s r-rQ JSON.__init__s&2 l3  "*  #r0c8\rSrSr%SrS\S'\SSj5rSrg) JSON.Comparator6Define comparison operations for :class:`_types.JSON`.r typec[URRR[R R 5(aQURRR[URRURRS9$URRR[URRURRS9$)zOn 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) r'exprrightrXsqltypesr r#leftoperaterrMr )r3s r-astextJSON.Comparator.astexts$))//.. 0J0JKKyy~~--#IIOO $ 5 5. yy~~--DIIOO9N9N.r0r2N)r1zColumnElement[str]) rArBrCrDrI__annotations__propertyrarEr2r0r- ComparatorrUsD    r0re)rM)FN)rOboolrMzOptional[TypeEngine[str]])rArBrCrDrIrender_bind_castr^TextrMrcrQr rercomparator_factoryrE __classcell__)rRs@r-r r [siKZ#+==?K2#15++/++:X]]--b1<$r0r cP\rSrSrSrSr"SS\R\5r\r Sr g)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|\rSrSr%SrS\S'SSjrSSjrSSjrSSjr SS jr SS jr SS jr SS jr S rg)JSONB.ComparatorirWr!rXcHUR[U[RS9$)zBoolean expression. Test for presence of a key (equivalent of the ``?`` operator). Note that the key may be a SQLA expression. rZ)r`rr^Booleanr3others r-has_keyJSONB.Comparator.has_key#<<H`` operator). kwargs may be ignored by this operator but are required for API conformance. rZ)r`rr^rp)r3rrkwargss r-containsJSONB.Comparator.contains5s<<%X=M=M<N Nr0cHUR[U[RS9$)zBoolean expression. Test if keys are a proper subset of the keys of the argument jsonb expression (equivalent of the ``<@`` operator). rZ)r`rr^rprqs r- contained_byJSONB.Comparator.contained_by?s' <<e1A1A  r0c[U[5(d [U5n[U[[R 55nUR [U[S9$)aJSONB 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 rZ) r' _pg_arrayrr r^TEXTr`rr!)r3r right_sides r- delete_pathJSONB.Comparator.delete_pathHsEeY//!%(eU8==%9:J<< ZU<K Kr0cHUR[U[RS9$)zBoolean expression. Test for presence of item given by the argument JSONPath expression (equivalent of the ``@?`` operator). .. versionadded:: 2.0 rZ)r`rr^rprqs r- path_existsJSONB.Comparator.path_existsXs' <<U0@0@  r0cHUR[U[RS9$)zBoolean 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 rZ)r`rr^rprqs r- path_matchJSONB.Comparator.path_matchbs'<<Ex/?/?  r0r2N)rrrr1ColumnElement[bool])rrrr}rr1r)r z Union[List[str], _pg_array[str]]r1zColumnElement[JSONB])rArBrCrDrIrcrsrwrzr~rrrrrEr2r0r-rernsID  N  N  N  O  L9 L ! L   r0rer2N) rArBrCrDrIrJr rerrirEr2r0r-r!r!s//bNOT__R(Ob$r0r!N)+ __future__rtypingrrrrrr r r r operatorsr rrrrrrrrrrr^sqlr sql._typingrengine.interfacesr sql.elementsr sql.type_apirrr__all__r r#rGr!r2r0r-rs# %#"&"!!,-25* P8==--P< | $L$8==L$^E$DE$r0