sqlalchemy.sql.type_api.UserDefinedType

class documentation

class UserDefinedType(ExternalType, TypeEngineMixin, TypeEngine[_T], util.EnsureKWArg): (source)

View In Hierarchy

Base for user defined types. This should be the base of new types. Note that for most cases, :class:`.TypeDecorator` is probably more appropriate:: import sqlalchemy.types as types class MyType(types.UserDefinedType): cache_ok = True def __init__(self, precision = 8): self.precision = precision def get_col_spec(self, **kw): return "MYTYPE(%s)" % self.precision def bind_processor(self, dialect): def process(value): return value return process def result_processor(self, dialect, coltype): def process(value): return value return process Once the type is made, it's immediately usable:: table = Table('foo', metadata_obj, Column('id', Integer, primary_key=True), Column('data', MyType(16)) ) The ``get_col_spec()`` method will in most cases receive a keyword argument ``type_expression`` which refers to the owning expression of the type as being compiled, such as a :class:`_schema.Column` or :func:`.cast` construct. This keyword is only sent if the method accepts keyword arguments (e.g. ``**kw``) in its argument signature; introspection is used to check for this in order to support legacy forms of this function. .. versionadded:: 1.0.0 the owning expression is passed to the ``get_col_spec()`` method via the keyword argument ``type_expression``, if it receives ``**kw`` in its signature. The :attr:`.UserDefinedType.cache_ok` class-level flag indicates if this custom :class:`.UserDefinedType` is safe to be used as part of a cache key. This flag defaults to ``None`` which will initially generate a warning when the SQL compiler attempts to generate a cache key for a statement that uses this type. If the :class:`.UserDefinedType` is not guaranteed to produce the same bind/result behavior and SQL generation every time, this flag should be set to ``False``; otherwise if the class produces the same behavior each time, it may be set to ``True``. See :attr:`.UserDefinedType.cache_ok` for further notes on how this works. .. versionadded:: 1.4.28 Generalized the :attr:`.ExternalType.cache_ok` flag so that it is available for both :class:`.TypeDecorator` as well as :class:`.UserDefinedType`.

Method coerce_compared_value Suggest a type for a 'coerced' Python value in an expression.
Class Variable __visit_name__ Undocumented
Class Variable ensure_kwarg a regular expression that indicates method names for which the method should accept ``**kw`` arguments.

Inherited from ExternalType:

Class Variable cache_ok Indicate if statements using this :class:`.ExternalType` are "safe to cache".
Property _static_cache_key Undocumented

Inherited from TypeEngineMixin (via ExternalType):

Method adapt Undocumented
Method dialect_impl Undocumented
Class Variable __slots__ Undocumented

Inherited from TypeEngine (via ExternalType, TypeEngineMixin):

Class Comparator Base class for custom comparison operations defined at the type level. See :attr:`.TypeEngine.comparator_factory`.
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 bind_processor Return a conversion function for processing bind values.
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 :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 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.
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 hashable Flag, if False, means values from this type aren't hashable.
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.
Property python_type Return the Python type object expected to be returned by instances of this type, if known.
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_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 _type_affinity Return a rudimental 'affinity' value expressing the general class of type.

Inherited from Visitable (via ExternalType, 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

Inherited from EnsureKWArg (via ExternalType, TypeEngineMixin, TypeEngine, Visitable):

Class Method _wrap_w_kw Undocumented
def coerce_compared_value(self, op: Optional[OperatorType], value: Any) -> TypeEngine[Any]: (source)
overrides sqlalchemy.sql.type_api.TypeEngine.coerce_compared_value

Suggest a type for a 'coerced' Python value in an expression. Default behavior for :class:`.UserDefinedType` is the same as that of :class:`.TypeDecorator`; by default it returns ``self``, assuming the compared value should be coerced into the same type as this one. See :meth:`.TypeDecorator.coerce_compared_value` for more detail.

__visit_name__: str = (source)
overrides sqlalchemy.sql.visitors.Visitable.__visit_name__

Undocumented

ensure_kwarg: str = (source)
overrides sqlalchemy.util.langhelpers.EnsureKWArg.ensure_kwarg

a regular expression that indicates method names for which the method should accept ``**kw`` arguments. The class will scan for methods matching the name template and decorate them if necessary to ensure ``**kw`` parameters are accepted.