class documentation

class JSON(sqltypes.JSON):

Known subclasses: sqlalchemy.dialects.postgresql.json.JSONB, sqlalchemy.dialects.postgresql.asyncpg.AsyncpgJSON, sqlalchemy.dialects.postgresql.pg8000._PGJSON, sqlalchemy.dialects.postgresql.psycopg2._PGJSON, sqlalchemy.dialects.postgresql.pygresql._PGJSON

View In Hierarchy

Represent the PostgreSQL JSON type.

_postgresql.JSON is used automatically whenever the base _types.JSON datatype is used against a PostgreSQL backend, however base _types.JSON datatype does not provide Python accessors for PostgreSQL-specific comparison methods such as _postgresql.JSON.Comparator.astext; additionally, to use PostgreSQL JSONB, the _postgresql.JSONB datatype should be used explicitly.

See Also

_types.JSON - main documentation for the generic cross-platform JSON datatype.

The operators provided by the PostgreSQL version of _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 .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 .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'
    
Changed in version 1.1: The _expression.ColumnElement.cast operator on JSON objects now requires that the .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 _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 _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.

See Also

_types.JSON - Core level JSON type

_postgresql.JSONB

Changed in version 1.1: _postgresql.JSON is now a PostgreSQL- specific specialization of the new _types.JSON type.
Class ​Comparator Define comparison operations for _types.JSON.
Method __init__ Construct a _types.JSON type.
Instance Variable astext​_type Undocumented

Inherited from JSON:

Class ​JSONElement​Type Common function for index / path elements in a JSON expression.
Class ​JSONIndex​Type Placeholder for the datatype of a JSON index value.
Class ​JSONInt​Index​Type Placeholder for the datatype of a JSON index value.
Class ​JSONPath​Type Placeholder type for JSON path operations.
Class ​JSONStr​Index​Type Placeholder for the datatype of a JSON index value.
Method bind​_processor Return a conversion function for processing bind values.
Method result​_processor Return a conversion function for processing result row values.
Constant NULL Describe the json value of NULL.
Method should​_evaluate​_none.setter Undocumented
Class Variable __visit​_name__ Undocumented
Class Variable hashable Flag, if False, means values from this type aren't hashable.
Instance Variable none​_as​_null Undocumented
Property ​_str​_impl Undocumented
Property python​_type Return the Python type object expected to be returned by instances of this type, if known.
Property should​_evaluate​_none Alias of _types.JSON.none_as_null

Inherited from TypeEngine (via JSON):

Method adapt Produce an "adapted" form of this type, given an "impl" class to work with.
Method as​_generic Return an instance of the generic type corresponding to this type using heuristic rule. The method may be overridden if this heuristic rule is not sufficient.
Method bind​_expression Given a bind value (i.e. a .BindParameter instance), return a SQL expression in its place.
Method coerce​_compared​_value Suggest a type for a 'coerced' Python value in an expression.
Method column​_expression Given a SELECT column expression, return a wrapping SQL expression.
Method compare​_against​_backend Compare this type against the given backend type.
Method compare​_values Compare two values for equality.
Method compile Produce a string-compiled form of this .TypeEngine.
Method dialect​_impl Return a dialect-specific implementation for this .TypeEngine.
Method evaluates​_none Return a copy of this type which has the .should_evaluate_none flag set to True.
Method get​_dbapi​_type Return the corresponding type object from the underlying DB-API, if any.
Method literal​_processor Return a conversion function for processing literal values that are to be rendered directly without using binds.
Method with​_variant Produce a new type object that will utilize the given type when applied to the dialect of the given name.
Class Variable sort​_key​_function A sorting function that can be passed as the key to sorted.
Static Method ​_to​_instance Undocumented
Method __repr__ Undocumented
Method __str__ Undocumented
Method ​_cached​_bind​_processor Return a dialect-specific bind processor for this type.
Method ​_cached​_custom​_processor Undocumented
Method ​_cached​_literal​_processor Return a dialect-specific literal processor for this type.
Method ​_cached​_result​_processor Return a dialect-specific result processor for this type.
Method ​_compare​_type​_affinity Undocumented
Method ​_default​_dialect Undocumented
Method ​_dialect​_info Return a dialect-specific registry which caches a dialect-specific implementation, bind processing function, and one or more result processing functions.
Method ​_gen​_dialect​_impl Undocumented
Method ​_resolve​_for​_literal adjust this type given a literal Python value that will be stored in a bound parameter.
Method ​_unwrapped​_dialect​_impl Return the 'unwrapped' dialect impl for this type.
Method copy Undocumented
Method copy​_value Undocumented
Class Variable ​_is​_array Undocumented
Class Variable ​_is​_table​_value Undocumented
Class Variable ​_is​_tuple​_type Undocumented
Class Variable ​_is​_type​_decorator Undocumented
Class Variable ​_isnull Undocumented
Class Variable ​_sqla​_type Undocumented
Property ​_generic​_type​_affinity Undocumented
Property ​_has​_bind​_expression memoized boolean, check if bind_expression is implemented.
Property ​_has​_column​_expression memoized boolean, check if column_expression is implemented.
Property ​_static​_cache​_key Undocumented
Property ​_type​_affinity Return a rudimental 'affinity' value expressing the general class of type.

Inherited from Traversible (via JSON, TypeEngine):

Method get​_children Return immediate child .visitors.Traversible elements of this .visitors.Traversible.
Method __class​_getitem__ Undocumented
def __init__(self, none_as_null=False, astext_type=None):
Construct a _types.JSON type.
Parameters
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 .null construct can still be used to persist a NULL value:

from sqlalchemy import null
conn.execute(table.insert(), data=null())
Changed in version 0.9.8: - Added none_as_null, and .null is now supported in order to persist a NULL value.

See Also

_types.JSON.NULL

astext​_type

the type to use for the .JSON.Comparator.astext accessor on indexed attributes. Defaults to _types.Text.

New in version 1.1.
astext_type =

Undocumented