JezK
Edit File: json.pyc
� 1��fc @@ s� d d l m Z d d l m Z d d l m Z d d l m Z d Z e j e j Z e j d d e d e d e �Z e j d d e d e d e �Z e j d d e d e d e �Z e j d d e d e d e �Z e j d d e d e d e �Z e j d d e d e d e �Z e j d d e d e d e �Z d e j j f d � � YZ d e j f d � � YZ d e f d � � YZ d S( i ( t absolute_importi ( t types( t util( t operatorst JSONt JSONBs ->>t precedencet natural_self_precedentt eager_groupings #>>t ?s ?&s ?|s @>s <@t JSONPathTypec B@ s e Z d � Z d � Z RS( c @ s" | j | � � � f d � } | S( Nc @ si t | t j j � s t � g | D] } t j | � ^ q" } d d j | � } � re � | � } n | S( Ns {%s}s , ( t isinstanceR t collections_abct Sequencet AssertionErrort text_typet join( t valuet elemt tokens( t super_proc( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyt processI s "( t string_bind_processor( t selft dialectR ( ( R sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyt bind_processorF s c @ s" | j | � � � f d � } | S( Nc @ si t | t j j � s t � g | D] } t j | � ^ q" } d d j | � } � re � | � } n | S( Ns {%s}s , ( R R R R R R R ( R R R ( R ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyR V s "( t string_literal_processor( R R R ( ( R sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyt literal_processorS s ( t __name__t __module__R R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyR E s c B@ sK e Z d Z e j � Z e d d � Z d e j j f d � � YZ e Z RS( s� 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' .. versionchanged:: 1.1 The :meth:`_expression.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:`_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://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` .. versionchanged:: 1.1 :class:`_postgresql.JSON` is now a PostgreSQL- specific specialization of the new :class:`_types.JSON` type. c C@ s5 t t | � j d | � | d k r1 | | _ n d S( s+ 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()) .. versionchanged:: 0.9.8 - Added ``none_as_null``, and :func:`.null` is now supported in order to persist a NULL value. .. 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`. .. versionadded:: 1.1 t none_as_nullN( t superR t __init__t Nonet astext_type( R R R" ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyR � s t Comparatorc B@ s e Z d Z e d � � Z RS( s6 Define comparison operations for :class:`_types.JSON`.c C@ sr t | j j j t j j � rF | j j j t | j j d | j j �S| j j j t | j j d | j j �Sd S( 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:`_expression.ColumnElement.cast` t result_typeN( R t exprt rightt typet sqltypesR R t leftt operatet JSONPATH_ASTEXTR" t ASTEXT( R ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyt astext� s ( R R t __doc__t propertyR- ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyR# � s N( R R R. R( t TextR" t FalseR! R R R# t comparator_factory( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyR a s R c B@ s3 e Z d Z d Z d e j f d � � YZ e Z RS( s� 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`, and :meth:`.JSONB.Comparator.contained_by`. 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. .. versionadded:: 0.9.7 .. seealso:: :class:`_types.JSON` R R# c B@ s; e Z d Z d � Z d � Z d � Z d � Z d � Z RS( s6 Define comparison operations for :class:`_types.JSON`.c C@ s | j t | d t j �S( s� Boolean expression. Test for presence of a key (equivalent of the ``?`` operator). Note that the key may be a SQLA expression. R$ ( R* t HAS_KEYR( t Boolean( R t other( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyt has_key( s c C@ s | j t | d t j �S( sx Boolean expression. Test for presence of all keys in jsonb (equivalent of the ``?&`` operator) R$ ( R* t HAS_ALLR( R4 ( R R5 ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyt has_all. s c C@ s | j t | d t j �S( sw Boolean expression. Test for presence of any key in jsonb (equivalent of the ``?|`` operator) R$ ( R* t HAS_ANYR( R4 ( R R5 ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyt has_any4 s c K@ s | j t | d t j �S( s" 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. R$ ( R* t CONTAINSR( R4 ( R R5 t kwargs( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyt contains: s c C@ s | j t | d t j �S( s� Boolean expression. Test if keys are a proper subset of the keys of the argument jsonb expression (equivalent of the ``<@`` operator). R$ ( R* t CONTAINED_BYR( R4 ( R R5 ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyt contained_byD s ( R R R. R6 R8 R: R= R? ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyR# % s ( R R R. t __visit_name__R R# R2 ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyR � s .(N( R R ( t __future__R t R R( R t sqlR t __all__t _PRECEDENCEt json_getitem_opt idx_precedencet custom_opt TrueR, R+ R3 R7 R9 R; R> R R R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyt <module> sV �