sqlalchemy.dialects.postgresql.ARRAY

class documentation

class ARRAY(sqltypes.ARRAY): (source)

Known subclasses: sqlalchemy.dialects.postgresql._psycopg_common._PsycopgARRAY, sqlalchemy.dialects.postgresql.pg8000._PGARRAY

View In Hierarchy

PostgreSQL ARRAY type. .. versionchanged:: 1.1 The :class:`_postgresql.ARRAY` type is now a subclass of the core :class:`_types.ARRAY` type. The :class:`_postgresql.ARRAY` type is constructed in the same way as the core :class:`_types.ARRAY` type; a member type is required, and a number of dimensions is recommended if the type is to be used for more than one dimension:: from sqlalchemy.dialects import postgresql mytable = Table("mytable", metadata, Column("data", postgresql.ARRAY(Integer, dimensions=2)) ) The :class:`_postgresql.ARRAY` type provides all operations defined on the core :class:`_types.ARRAY` type, including support for "dimensions", indexed access, and simple matching such as :meth:`.types.ARRAY.Comparator.any` and :meth:`.types.ARRAY.Comparator.all`. :class:`_postgresql.ARRAY` class also provides PostgreSQL-specific methods for containment operations, including :meth:`.postgresql.ARRAY.Comparator.contains` :meth:`.postgresql.ARRAY.Comparator.contained_by`, and :meth:`.postgresql.ARRAY.Comparator.overlap`, e.g.:: mytable.c.data.contains([1, 2]) The :class:`_postgresql.ARRAY` type may not be supported on all PostgreSQL DBAPIs; it is currently known to work on psycopg2 only. Additionally, the :class:`_postgresql.ARRAY` type does not work directly in conjunction with the :class:`.ENUM` type. For a workaround, see the special type at :ref:`postgresql_array_of_enum`. .. container:: topic **Detecting Changes in ARRAY columns when using the ORM** The :class:`_postgresql.ARRAY` type, when used with the SQLAlchemy ORM, does not detect in-place mutations to the array. In order to detect these, the :mod:`sqlalchemy.ext.mutable` extension must be used, using the :class:`.MutableList` class:: from sqlalchemy.dialects.postgresql import ARRAY from sqlalchemy.ext.mutable import MutableList class SomeOrmClass(Base): # ... data = Column(MutableList.as_mutable(ARRAY(Integer))) This extension will allow "in-place" changes such to the array such as ``.append()`` to produce events which will be detected by the unit of work. Note that changes to elements **inside** the array, including subarrays that are mutated in place, are **not** detected. Alternatively, assigning a new array value to an ORM element that replaces the old one will always trigger a change event. .. seealso:: :class:`_types.ARRAY` - base array type :class:`_postgresql.array` - produces a literal array value.

Class Comparator Define comparison operations for :class:`_types.ARRAY`.
Method __init__ Construct an ARRAY.
Method bind_processor Return a conversion function for processing bind values.
Method compare_values Compare two values for equality.
Method literal_processor Return a conversion function for processing literal values that are to be rendered directly without using binds.
Method result_processor Return a conversion function for processing result row values.
Instance Variable as_tuple Undocumented
Instance Variable dimensions Undocumented
Instance Variable item_type Undocumented
Instance Variable zero_indexes If True, Python zero-based indexes should be interpreted as one-based on the SQL expression side.
Property hashable Flag, if False, means values from this type aren't hashable.
Property python_type Return the Python type object expected to be returned by instances of this type, if known.
Property _against_native_enum Undocumented

Inherited from ARRAY:

Class Variable __visit_name__ Undocumented
Method _apply_item_processor Helper method that can be used by bind_processor(), literal_processor(), etc. to apply an item processor to elements of an array value, taking into account the 'dimensions' for this array type.
Method _set_parent Support SchemaEventTarget
Method _set_parent_with_dispatch Support SchemaEventTarget
Class Variable _is_array Undocumented

Inherited from SchemaEventTarget (via ARRAY):

Class Variable dispatch Undocumented

Inherited from EventTarget (via ARRAY, SchemaEventTarget):

Class Variable __slots__ Undocumented

Inherited from TypeEngineMixin (via ARRAY, SchemaEventTarget, EventTarget, Indexable, Concatenable):

Method adapt Undocumented
Method dialect_impl Undocumented
Property _static_cache_key Undocumented

Inherited from TypeEngine (via ARRAY, SchemaEventTarget, EventTarget, Indexable, Concatenable, TypeEngineMixin):

Method __repr__ Undocumented
Method __str__ Undocumented
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 :class:`.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 compile Produce a string-compiled form of this :class:`.TypeEngine`.
Method copy Undocumented
Method copy_value Undocumented
Method evaluates_none Return a copy of this type which has the :attr:`.should_evaluate_none` flag set to True.
Method get_dbapi_type Return the corresponding type object from the underlying DB-API, if any.
Method with_variant Produce a copy of this type object that will utilize the given type when applied to the dialect of the given name.
Class Variable render_bind_cast Render bind casts for :attr:`.BindTyping.RENDER_CASTS` mode.
Class Variable render_literal_cast render casts when rendering a value as an inline literal, e.g. with :meth:`.TypeEngine.literal_processor`.
Class Variable should_evaluate_none If True, the Python constant ``None`` is considered to be handled explicitly by this type.
Class Variable sort_key_function A sorting function that can be passed as the key to sorted.
Static Method _to_instance Undocumented
Method _cached_bind_processor Return a dialect-specific bind processor for this type.
Method _cached_custom_processor return a dialect-specific processing object for custom purposes.
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 _resolve_for_python_type given a Python type (e.g. ``int``, ``str``, etc. ) return an instance of this :class:`.TypeEngine` that's appropriate for this type.
Method _unwrapped_dialect_impl Return the 'unwrapped' dialect impl for this type.
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 _type_affinity Return a rudimental 'affinity' value expressing the general class of type.

Inherited from Visitable (via ARRAY, SchemaEventTarget, EventTarget, Indexable, Concatenable, TypeEngineMixin, TypeEngine):

Method __class_getitem__ Undocumented
Method __init_subclass__ Undocumented
Class Method _generate_compiler_dispatch Undocumented
Method _compiler_dispatch Undocumented
Class Variable _original_compiler_dispatch Undocumented
def __init__(self, item_type: _TypeEngineArgument[Any], as_tuple: bool = False, dimensions: Optional[int] = None, zero_indexes: bool = False): (source)
overrides sqlalchemy.sql.sqltypes.ARRAY.__init__

Construct an ARRAY. E.g.:: Column('myarray', ARRAY(Integer)) Arguments are: :param item_type: The data type of items of this array. Note that dimensionality is irrelevant here, so multi-dimensional arrays like ``INTEGER[][]``, are constructed as ``ARRAY(Integer)``, not as ``ARRAY(ARRAY(Integer))`` or such. :param as_tuple=False: Specify whether return results should be converted to tuples from lists. DBAPIs such as psycopg2 return lists by default. When tuples are returned, the results are hashable. :param dimensions: if non-None, the ARRAY will assume a fixed number of dimensions. This will cause the DDL emitted for this ARRAY to include the exact number of bracket clauses ``[]``, and will also optimize the performance of the type overall. Note that PG arrays are always implicitly "non-dimensioned", meaning they can store any number of dimensions no matter how they were declared. :param zero_indexes=False: when True, index values will be converted between Python zero-based and PostgreSQL one-based indexes, e.g. a value of one will be added to all index values before passing to the database. .. versionadded:: 0.9.5

def bind_processor(self, dialect): (source)
overrides sqlalchemy.sql.type_api.TypeEngine.bind_processor

Return a conversion function for processing bind values. Returns a callable which will receive a bind parameter value as the sole positional argument and will return a value to send to the DB-API. If processing is not necessary, the method should return ``None``. .. note:: This method is only called relative to a **dialect specific type object**, which is often **private to a dialect in use** and is not the same type object as the public facing one, which means it's not feasible to subclass a :class:`.types.TypeEngine` class in order to provide an alternate :meth:`_types.TypeEngine.bind_processor` method, unless subclassing the :class:`_types.UserDefinedType` class explicitly. To provide alternate behavior for :meth:`_types.TypeEngine.bind_processor`, implement a :class:`_types.TypeDecorator` class and provide an implementation of :meth:`_types.TypeDecorator.process_bind_param`. .. seealso:: :ref:`types_typedecorator` :param dialect: Dialect instance in use.

def compare_values(self, x, y): (source)
overrides sqlalchemy.sql.sqltypes.ARRAY.compare_values

Compare two values for equality.

def literal_processor(self, dialect): (source)
overrides sqlalchemy.sql.sqltypes.ARRAY.literal_processor

Return a conversion function for processing literal values that are to be rendered directly without using binds. This function is used when the compiler makes use of the "literal_binds" flag, typically used in DDL generation as well as in certain scenarios where backends don't accept bound parameters. Returns a callable which will receive a literal Python value as the sole positional argument and will return a string representation to be rendered in a SQL statement. .. note:: This method is only called relative to a **dialect specific type object**, which is often **private to a dialect in use** and is not the same type object as the public facing one, which means it's not feasible to subclass a :class:`.types.TypeEngine` class in order to provide an alternate :meth:`_types.TypeEngine.literal_processor` method, unless subclassing the :class:`_types.UserDefinedType` class explicitly. To provide alternate behavior for :meth:`_types.TypeEngine.literal_processor`, implement a :class:`_types.TypeDecorator` class and provide an implementation of :meth:`_types.TypeDecorator.process_literal_param`. .. seealso:: :ref:`types_typedecorator`

def result_processor(self, dialect, coltype): (source)
overrides sqlalchemy.sql.type_api.TypeEngine.result_processor

Return a conversion function for processing result row values. Returns a callable which will receive a result row column value as the sole positional argument and will return a value to return to the user. If processing is not necessary, the method should return ``None``. .. note:: This method is only called relative to a **dialect specific type object**, which is often **private to a dialect in use** and is not the same type object as the public facing one, which means it's not feasible to subclass a :class:`.types.TypeEngine` class in order to provide an alternate :meth:`_types.TypeEngine.result_processor` method, unless subclassing the :class:`_types.UserDefinedType` class explicitly. To provide alternate behavior for :meth:`_types.TypeEngine.result_processor`, implement a :class:`_types.TypeDecorator` class and provide an implementation of :meth:`_types.TypeDecorator.process_result_value`. .. seealso:: :ref:`types_typedecorator` :param dialect: Dialect instance in use. :param coltype: DBAPI coltype argument received in cursor.description.

as_tuple = (source)
overrides sqlalchemy.sql.sqltypes.ARRAY.as_tuple

Undocumented

dimensions = (source)
overrides sqlalchemy.sql.sqltypes.ARRAY.dimensions

Undocumented

item_type = (source)
overrides sqlalchemy.sql.sqltypes.ARRAY.item_type

Undocumented

zero_indexes = (source)
overrides sqlalchemy.sql.sqltypes.ARRAY.zero_indexes

If True, Python zero-based indexes should be interpreted as one-based on the SQL expression side.

@property
hashable = (source)
overrides sqlalchemy.sql.sqltypes.ARRAY.hashable

Flag, if False, means values from this type aren't hashable. Used by the ORM when uniquing result lists.

@property
python_type = (source)
overrides sqlalchemy.sql.sqltypes.ARRAY.python_type

Return the Python type object expected to be returned by instances of this type, if known. Basically, for those types which enforce a return type, or are known across the board to do such for all common DBAPIs (like ``int`` for example), will return that type. If a return type is not defined, raises ``NotImplementedError``. Note that any type also accommodates NULL in SQL which means you can also get back ``None`` from any type in practice.

@util.memoized_property
_against_native_enum = (source)

Undocumented