sqlalchemy.sql.sqltypes.Boolean

class documentation

class Boolean(SchemaType, Emulated, TypeEngine[bool]): (source)

Known subclasses: sqlalchemy.dialects.mssql.BIT, sqlalchemy.dialects.postgresql.asyncpg.AsyncpgBoolean, sqlalchemy.sql.sqltypes.BOOLEAN, sqlalchemy.sql.sqltypes.MatchType, sqlalchemy.dialects.oracle.types._OracleBoolean, sqlalchemy.dialects.postgresql.pg8000._PGBoolean, sqlalchemy.dialects.postgresql.psycopg._PGBoolean

View In Hierarchy

A bool datatype. :class:`.Boolean` typically uses BOOLEAN or SMALLINT on the DDL side, and on the Python side deals in ``True`` or ``False``. The :class:`.Boolean` datatype currently has two levels of assertion that the values persisted are simple true/false values. For all backends, only the Python values ``None``, ``True``, ``False``, ``1`` or ``0`` are accepted as parameter values. For those backends that don't support a "native boolean" datatype, an option exists to also create a CHECK constraint on the target column .. versionchanged:: 1.2 the :class:`.Boolean` datatype now asserts that incoming Python values are already in pure boolean form.

Method __init__ Construct a Boolean.
Method bind_processor Return a conversion function for processing bind values.
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.
Class Variable __visit_name__ Undocumented
Class Variable native Undocumented
Instance Variable create_constraint Undocumented
Instance Variable dispatch Undocumented
Instance Variable name Undocumented
Property python_type Return the Python type object expected to be returned by instances of this type, if known.
Method _set_table Undocumented
Method _should_create_constraint Undocumented
Method _strict_as_bool Undocumented
Class Variable _strict_bools Undocumented
Instance Variable _create_events Undocumented

Inherited from SchemaType:

Method adapt Undocumented
Method copy Undocumented
Method create Issue CREATE DDL for this type, if applicable.
Method drop Issue DROP DDL for this type, if applicable.
Instance Variable inherit_schema Undocumented
Instance Variable metadata Undocumented
Instance Variable schema Undocumented
Method _is_impl_for_variant Undocumented
Method _on_metadata_create Undocumented
Method _on_metadata_drop Undocumented
Method _on_table_create Undocumented
Method _on_table_drop Undocumented
Method _set_parent Associate with this SchemaEvent's parent object.
Method _variant_mapping_for_set_table Undocumented
Class Variable _use_schema_map Undocumented

Inherited from SchemaEventTarget (via SchemaType):

Method _set_parent_with_dispatch Undocumented

Inherited from EventTarget (via SchemaType, SchemaEventTarget):

Class Variable __slots__ Undocumented

Inherited from Emulated (via SchemaType, SchemaEventTarget, EventTarget):

Method adapt_to_emulated Given an impl class, adapt this type to the impl assuming "emulated".

Inherited from TypeEngineMixin (via SchemaType, SchemaEventTarget, EventTarget, Emulated):

Method dialect_impl Undocumented
Property _static_cache_key Undocumented

Inherited from TypeEngine (via SchemaType, SchemaEventTarget, EventTarget, Emulated, 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 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 :class:`.TypeEngine`.
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 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.
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 SchemaType, SchemaEventTarget, EventTarget, Emulated, 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, create_constraint: bool = False, name: Optional[str] = None, _create_events: bool = True, _adapted_from: Optional[SchemaType] = None): (source)
overrides sqlalchemy.sql.sqltypes.SchemaType.__init__
overridden in sqlalchemy.dialects.mysql.types._MatchType

Construct a Boolean. :param create_constraint: defaults to False. If the boolean is generated as an int/smallint, also create a CHECK constraint on the table that ensures 1 or 0 as a value. .. note:: it is strongly recommended that the CHECK constraint have an explicit name in order to support schema-management concerns. This can be established either by setting the :paramref:`.Boolean.name` parameter or by setting up an appropriate naming convention; see :ref:`constraint_naming_conventions` for background. .. versionchanged:: 1.4 - this flag now defaults to False, meaning no CHECK constraint is generated for a non-native enumerated type. :param name: if a CHECK constraint is generated, specify the name of the constraint.

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 literal_processor(self, dialect): (source)
overrides sqlalchemy.sql.type_api.TypeEngine.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.

__visit_name__: str = (source)
overrides sqlalchemy.sql.visitors.Visitable.__visit_name__
overridden in sqlalchemy.dialects.mssql.BIT, sqlalchemy.sql.sqltypes.BOOLEAN

Undocumented

native: bool = (source)
overrides sqlalchemy.sql.type_api.Emulated.native

Undocumented

create_constraint = (source)

Undocumented

dispatch = (source)
overrides sqlalchemy.sql.sqltypes.SchemaType.dispatch

Undocumented

name = (source)
overrides sqlalchemy.sql.sqltypes.SchemaType.name

Undocumented

@property
python_type = (source)
overrides sqlalchemy.sql.type_api.TypeEngine.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.preload_module('sqlalchemy.sql.schema')
def _set_table(self, column, table): (source)
overrides sqlalchemy.sql.sqltypes.SchemaType._set_table

Undocumented

def _should_create_constraint(self, compiler, **kw): (source)

Undocumented

def _strict_as_bool(self, value): (source)

Undocumented

_strict_bools = (source)

Undocumented

_create_events = (source)
overrides sqlalchemy.sql.sqltypes.SchemaType._create_events

Undocumented