sqlalchemy.dialects.mysql.SET

class documentation

class SET(_StringType): (source)

View In Hierarchy

MySQL SET type.

Method __init__ Construct a SET.
Method __repr__ Undocumented
Method adapt Produce an "adapted" form of this type, given an "impl" class to work with.
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 result_processor Return a conversion function for processing result row values.
Class Variable __visit_name__ Undocumented
Instance Variable retrieve_as_bitwise Undocumented
Instance Variable values Undocumented
Instance Variable _bitmap Undocumented

Inherited from _StringType:

Instance Variable ascii Undocumented
Instance Variable binary Undocumented
Instance Variable charset Undocumented
Instance Variable national Undocumented
Instance Variable unicode Undocumented

Inherited from String (via _StringType):

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.
Instance Variable collation Undocumented
Instance Variable length Undocumented
Property python_type Return the Python type object expected to be returned by instances of this type, if known.
Method _resolve_for_literal adjust this type given a literal Python value that will be stored in a bound parameter.

Inherited from Concatenable (via _StringType, String):

Class Comparator Undocumented

Inherited from TypeEngineMixin (via _StringType, String, Concatenable):

Method dialect_impl Undocumented
Class Variable __slots__ Undocumented
Property _static_cache_key Undocumented

Inherited from TypeEngine (via _StringType, String, Concatenable, TypeEngineMixin):

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 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 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_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 _StringType, String, 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, *values, **kw): (source)
overrides sqlalchemy.dialects.mysql.types._StringType.__init__

Construct a SET. E.g.:: Column('myset', SET("foo", "bar", "baz")) The list of potential values is required in the case that this set will be used to generate DDL for a table, or if the :paramref:`.SET.retrieve_as_bitwise` flag is set to True. :param values: The range of valid values for this SET. The values are not quoted, they will be escaped and surrounded by single quotes when generating the schema. :param convert_unicode: Same flag as that of :paramref:`.String.convert_unicode`. :param collation: same as that of :paramref:`.String.collation` :param charset: same as that of :paramref:`.VARCHAR.charset`. :param ascii: same as that of :paramref:`.VARCHAR.ascii`. :param unicode: same as that of :paramref:`.VARCHAR.unicode`. :param binary: same as that of :paramref:`.VARCHAR.binary`. :param retrieve_as_bitwise: if True, the data for the set type will be persisted and selected using an integer value, where a set is coerced into a bitwise mask for persistence. MySQL allows this mode which has the advantage of being able to store values unambiguously, such as the blank string ``''``. The datatype will appear as the expression ``col + 0`` in a SELECT statement, so that the value is coerced into an integer value in result sets. This flag is required if one wishes to persist a set that can store the blank string ``''`` as a value. .. warning:: When using :paramref:`.mysql.SET.retrieve_as_bitwise`, it is essential that the list of set values is expressed in the **exact same order** as exists on the MySQL database. .. versionadded:: 1.0.0

def __repr__(self): (source)
overrides sqlalchemy.dialects.mysql.types._StringType.__repr__

Undocumented

def adapt(self, impltype, **kw): (source)
overrides sqlalchemy.sql.type_api.TypeEngineMixin.adapt

Produce an "adapted" form of this type, given an "impl" class to work with. This method is used internally to associate generic types with "implementation" types that are specific to a particular dialect.

def bind_processor(self, dialect): (source)
overrides sqlalchemy.sql.sqltypes.String.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 column_expression(self, colexpr): (source)
overrides sqlalchemy.sql.type_api.TypeEngine.column_expression

Given a SELECT column expression, return a wrapping SQL expression. This is typically a SQL function that wraps a column expression as rendered in the columns clause of a SELECT statement. It is used for special data types that require columns to be wrapped in some special database function in order to coerce the value before being sent back to the application. It is the SQL analogue of the :meth:`.TypeEngine.result_processor` method. This method is called during the **SQL compilation** phase of a statement, when rendering a SQL string. It is **not** called against specific values. .. 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.column_expression` method, unless subclassing the :class:`_types.UserDefinedType` class explicitly. To provide alternate behavior for :meth:`_types.TypeEngine.column_expression`, implement a :class:`_types.TypeDecorator` class and provide an implementation of :meth:`_types.TypeDecorator.column_expression`. .. seealso:: :ref:`types_typedecorator` .. seealso:: :ref:`types_sql_value_processing`

def result_processor(self, dialect, coltype): (source)
overrides sqlalchemy.sql.sqltypes.String.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.sqltypes.String.__visit_name__

Undocumented

retrieve_as_bitwise = (source)

Undocumented

values = (source)

Undocumented

_bitmap = (source)

Undocumented