sqlmodel API Reference
Full documentation for sqlmodel (0.0.39)
sqlmodel.ARRAY
Python Library Documentation: class ARRAY in module sqlalchemy.sql.sqltypes
class ARRAY(sqlalchemy.sql.base.SchemaEventTarget, Indexable, Concatenable, sqlalchemy.sql.type_api.TypeEngine)
| ARRAY(item_type: '_TypeEngineArgument[_T]', as_tuple: 'bool' = False, dimensions: 'Optional[int]' = None, zero_indexes: 'bool' = False)
|
| Represent a SQL Array type.
|
| .. note:: This type serves as the basis for all ARRAY operations.
| However, currently **only the PostgreSQL backend has support for SQL
| arrays in SQLAlchemy**. It is recommended to use the PostgreSQL-specific
| :class:`sqlalchemy.dialects.postgresql.ARRAY` type directly when using
| ARRAY types with PostgreSQL, as it provides additional operators
| specific to that backend.
|
| :class:`_types.ARRAY` is part of the Core in support of various SQL
| standard functions such as :class:`_functions.array_agg`
| which explicitly involve
| arrays; however, with the exception of the PostgreSQL backend and possibly
| some third-party dialects, no other SQLAlchemy built-in dialect has support
| for this type.
|
| An :class:`_types.ARRAY` type is constructed given the "type"
| of element::
|
| mytable = Table("mytable", metadata, Column("data", ARRAY(Integer)))
|
| The above type represents an N-dimensional array,
| meaning a supporting backend such as PostgreSQL will interpret values
| with any number of dimensions automatically. To produce an INSERT
| construct that passes in a 1-dimensional array of integers::
|
| connection.execute(mytable.insert(), {"data": [1, 2, 3]})
|
| The :class:`_types.ARRAY` type can be constructed given a fixed number
| of dimensions::
|
| mytable = Table(
| "mytable", metadata, Column("data", ARRAY(Integer, dimensions=2))
| )
|
| Sending a number of dimensions is optional, but recommended if the
| datatype is to represent arrays of more than one dimension. This number
| is used:
|
| * When emitting the type declaration itself to the database, e.g.
| ``INTEGER[][]``
|
| * When translating Python values to database values, and vice versa, e.g.
| an ARRAY of :class:`.Unicode` objects uses this number to efficiently
| access the string values inside of array structures without resorting
| to per-row type inspection
|
| * When used with the Python ``getitem`` accessor, the number of dimensions
| serves to define the kind of type that the ``[]`` operator should
| return, e.g. for an ARRAY of INTEGER with two dimensions::
|
| >>> expr = table.c.column[5] # returns ARRAY(Integer, dimensions=1)
| >>> expr = expr[6] # returns Integer
|
| For 1-dimensional arrays, an :class:`_types.ARRAY` instance with no
| dimension parameter will generally assume single-dimensional behaviors.
|
| SQL expressions of type :class:`_types.ARRAY` have support for "index" and
| "slice" behavior. The ``[]`` operator produces expression
| constructs which will produce the appropriate SQL, both for
| SELECT statements::
|
| select(mytable.c.data[5], mytable.c.data[2:7])
|
| as well as UPDATE statements when the :meth:`_expression.Update.values`
| method is used::
|
| mytable.update().values(
| {mytable.c.data[5]: 7, mytable.c.data[2:7]: [1, 2, 3]}
| )
|
| Indexed access is one-based by default;
| for zero-based index conversion, set :paramref:`_types.ARRAY.zero_indexes`.
|
| The :class:`_types.ARRAY` type also provides for the operators
| :meth:`.types.ARRAY.Comparator.any` and
| :meth:`.types.ARRAY.Comparator.all`. The PostgreSQL-specific version of
| :class:`_types.ARRAY` also provides additional operators.
|
| .. container:: topic
|
| **Detecting Changes in ARRAY columns when using the ORM**
|
| The :class:`_sqltypes.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 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:`sqlalchemy.dialects.postgresql.ARRAY`
|
| Method resolution order:
| ARRAY
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| Indexable
| Concatenable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, item_type: '_TypeEngineArgument[_T]', as_tuple: 'bool' = False, dimensions: 'Optional[int]' = None, zero_indexes: 'bool' = False)
| Construct an :class:`_types.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. This parameter is
| not generally needed as a Python list corresponds well
| to a SQL array.
|
| :param dimensions: if non-None, the ARRAY will assume a fixed
| number of dimensions. This impacts how the array is declared
| on the database, how it goes about interpreting Python and
| result values, as well as how expression behavior in conjunction
| with the "getitem" operator works. See the description at
| :class:`_types.ARRAY` for additional detail.
|
| :param zero_indexes=False: when True, index values will be converted
| between Python zero-based and SQL one-based indexes, e.g.
| a value of one will be added to all index values before passing
| to the database.
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| literal_processor(self, dialect: 'Dialect') -> 'Optional[_LiteralProcessorType[_T]]'
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| hashable
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.ARRAY.Comparator'>
| Define comparison operations for :class:`_types.ARRAY`.
|
| More operators are available on the dialect-specific form
| of this type. See :class:`.postgresql.ARRAY.Comparator`.
|
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'ARRAY'
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.ARRAY.Comparator'...
| Define comparison operations for :class:`_types.ARRAY`.
|
| More operators are available on the dialect-specific form
| of this type. See :class:`.postgresql.ARRAY.Comparator`.
|
|
| zero_indexes = False
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| get_dbapi_type(self, dbapi: 'DBAPIModule') -> 'Optional[Any]'
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.AutoString
Python Library Documentation: class AutoString in module sqlmodel.sql.sqltypes
class AutoString(sqlalchemy.sql.type_api.TypeDecorator)
| AutoString(*args: 'Any', **kwargs: 'Any')
|
| Method resolution order:
| AutoString
| sqlalchemy.sql.type_api.TypeDecorator
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.type_api.ExternalType
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| load_dialect_impl(self, dialect: sqlalchemy.engine.interfaces.Dialect) -> 'types.TypeEngine[Any]'
| Return a :class:`.TypeEngine` object corresponding to a dialect.
|
| This is an end-user override hook that can be used to provide
| differing types depending on the given dialect. It is used
| by the :class:`.TypeDecorator` implementation of :meth:`type_engine`
| to help determine what type should ultimately be returned
| for a given :class:`.TypeDecorator`.
|
| By default returns ``self.impl``.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| cache_ok = True
|
| impl = <class 'sqlalchemy.sql.sqltypes.String'>
| The base for all string and character types.
|
| In SQL, corresponds to VARCHAR.
|
| The `length` field is usually required when the `String` type is
| used within a CREATE TABLE statement, as VARCHAR requires a length
| on most databases.
|
|
| mysql_default_length = 255
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeDecorator:
|
| __getattr__(self, key: 'str') -> 'Any'
| Proxy all other undefined accessors to the underlying
| implementation.
|
| __init__(self, *args: 'Any', **kwargs: 'Any')
| Construct a :class:`.TypeDecorator`.
|
| Arguments sent here are passed to the constructor
| of the class assigned to the ``impl`` class level attribute,
| assuming the ``impl`` is a callable, and the resulting
| object is assigned to the ``self.impl`` instance attribute
| (thus overriding the class attribute of the same name).
|
| If the class level ``impl`` is not a callable (the unusual case),
| it will be assigned to the same instance attribute 'as-is',
| ignoring those arguments passed to the constructor.
|
| Subclasses can override this to customize the generation
| of ``self.impl`` entirely.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| bind_expression(self, bindparam: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression which will typically wrap the given parameter.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** necessarily
| called against specific values, and should not be confused with the
| :meth:`_types.TypeDecorator.process_bind_param` method, which is
| the more typical method that processes the actual value passed to a
| particular parameter at statement execution time.
|
| Subclasses of :class:`_types.TypeDecorator` can override this method
| to provide custom bind expression behavior for the type. This
| implementation will **replace** that of the underlying implementation
| type.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| Provide a bound value processing function for the
| given :class:`.Dialect`.
|
| This is the method that fulfills the :class:`.TypeEngine`
| contract for bound value conversion which normally occurs via
| the :meth:`_types.TypeEngine.bind_processor` method.
|
| .. note::
|
| User-defined subclasses of :class:`_types.TypeDecorator` should
| **not** implement this method, and should instead implement
| :meth:`_types.TypeDecorator.process_bind_param` so that the "inner"
| processing provided by the implementing type is maintained.
|
| :param dialect: Dialect instance in use.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'Any'
| Suggest a type for a 'coerced' Python value in an expression.
|
| By default, returns self. This method is called by
| the expression system when an object using this type is
| on the left or right side of an expression against a plain Python
| object which does not yet have a SQLAlchemy type assigned::
|
| expr = table.c.somecolumn + 35
|
| Where above, if ``somecolumn`` uses this type, this method will
| be called with the value ``operator.add``
| and ``35``. The return value is whatever SQLAlchemy type should
| be used for ``35`` for this particular operation.
|
| column_expression(self, column: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a SELECT column expression, return a wrapping SQL expression.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values, and should not be confused with the
| :meth:`_types.TypeDecorator.process_result_value` method, which is
| the more typical method that processes the actual value returned
| in a result row subsequent to statement execution time.
|
| Subclasses of :class:`_types.TypeDecorator` can override this method
| to provide custom column expression behavior for the type. This
| implementation will **replace** that of the underlying implementation
| type.
|
| See the description of :meth:`_types.TypeEngine.column_expression`
| for a complete description of the method's use.
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Given two values, compare them for equality.
|
| By default this calls upon :meth:`.TypeEngine.compare_values`
| of the underlying "impl", which in turn usually
| uses the Python equals operator ``==``.
|
| This function is used by the ORM to compare
| an original-loaded value with an intercepted
| "changed" value, to determine if a net change
| has occurred.
|
| copy(self, **kw: 'Any') -> 'Self'
| Produce a copy of this :class:`.TypeDecorator` instance.
|
| This is a shallow copy and is provided to fulfill part of
| the :class:`.TypeEngine` contract. It usually does not
| need to be overridden unless the user-defined :class:`.TypeDecorator`
| has local state that should be deep-copied.
|
| get_dbapi_type(self, dbapi: 'DBAPIModule') -> 'Optional[Any]'
| Return the DBAPI type object represented by this
| :class:`.TypeDecorator`.
|
| By default this calls upon :meth:`.TypeEngine.get_dbapi_type` of the
| underlying "impl".
|
| impl_instance(...)
|
| literal_processor(self, dialect: 'Dialect') -> 'Optional[_LiteralProcessorType[_T]]'
| Provide a literal processing function for the given
| :class:`.Dialect`.
|
| This is the method that fulfills the :class:`.TypeEngine`
| contract for literal value conversion which normally occurs via
| the :meth:`_types.TypeEngine.literal_processor` method.
|
| .. note::
|
| User-defined subclasses of :class:`_types.TypeDecorator` should
| **not** implement this method, and should instead implement
| :meth:`_types.TypeDecorator.process_literal_param` so that the
| "inner" processing provided by the implementing type is maintained.
|
| process_bind_param(self, value: 'Optional[_T]', dialect: 'Dialect') -> 'Any'
| Receive a bound parameter value to be converted.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for incoming data values.
| This method is called at **statement execution time** and is passed
| the literal Python data value which is to be associated with a bound
| parameter in the statement.
|
| The operation could be anything desired to perform custom
| behavior, such as transforming or serializing data.
| This could also be used as a hook for validating logic.
|
| :param value: Data to operate upon, of any type expected by
| this method in the subclass. Can be ``None``.
| :param dialect: the :class:`.Dialect` in use.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| :meth:`_types.TypeDecorator.process_result_value`
|
| process_literal_param(self, value: 'Optional[_T]', dialect: 'Dialect') -> 'str'
| Receive a literal parameter value to be rendered inline within
| a statement.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. Unlike other SQL
| compilation methods, it is passed a specific Python value to be
| rendered as a string. However it should not be confused with the
| :meth:`_types.TypeDecorator.process_bind_param` method, which is
| the more typical method that processes the actual value passed to a
| particular parameter at statement execution time.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for incoming data values
| that are in the special case of being rendered as literals.
|
| The returned string will be rendered into the output string.
|
| process_result_value(self, value: 'Optional[Any]', dialect: 'Dialect') -> 'Optional[_T]'
| Receive a result-row column value to be converted.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for data values
| being received in result rows coming from the database.
| This method is called at **result fetching time** and is passed
| the literal Python data value that's extracted from a database result
| row.
|
| The operation could be anything desired to perform custom
| behavior, such as transforming or deserializing data.
|
| :param value: Data to operate upon, of any type expected by
| this method in the subclass. Can be ``None``.
| :param dialect: the :class:`.Dialect` in use.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| :meth:`_types.TypeDecorator.process_bind_param`
|
| result_processor(self, dialect: 'Dialect', coltype: 'Any') -> 'Optional[_ResultProcessorType[_T]]'
| Provide a result value processing function for the given
| :class:`.Dialect`.
|
| This is the method that fulfills the :class:`.TypeEngine`
| contract for bound value conversion which normally occurs via
| the :meth:`_types.TypeEngine.result_processor` method.
|
| .. note::
|
| User-defined subclasses of :class:`_types.TypeDecorator` should
| **not** implement this method, and should instead implement
| :meth:`_types.TypeDecorator.process_result_value` so that the
| "inner" processing provided by the implementing type is maintained.
|
| :param dialect: Dialect instance in use.
| :param coltype: A SQLAlchemy data type
|
| type_engine(self, dialect: 'Dialect') -> 'TypeEngine[Any]'
| Return a dialect-specific :class:`.TypeEngine` instance
| for this :class:`.TypeDecorator`.
|
| In most cases this returns a dialect-adapted form of
| the :class:`.TypeEngine` type represented by ``self.impl``.
| Makes usage of :meth:`dialect_impl`.
| Behavior can be customized here by overriding
| :meth:`load_dialect_impl`.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.type_api.TypeDecorator:
|
| comparator_factory
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
| sort_key_function
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeDecorator:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeDecorator.Comparator'...
| A :class:`.TypeEngine.Comparator` that is specific to
| :class:`.TypeDecorator`.
|
| User-defined :class:`.TypeDecorator` classes should not typically
| need to modify this.
|
|
| __visit_name__ = 'type_decorator'
|
| coerce_to_is_types = (<class 'NoneType'>,)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from 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.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.BIGINT
Python Library Documentation: class BIGINT in module sqlalchemy.sql.sqltypes
class BIGINT(BigInteger)
| The SQL BIGINT type.
|
| .. seealso::
|
| :class:`_types.BigInteger` - documentation for the base type.
|
| Method resolution order:
| BIGINT
| BigInteger
| Integer
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'BIGINT'
|
| ----------------------------------------------------------------------
| Methods inherited from Integer:
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Integer:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.BINARY
Python Library Documentation: class BINARY in module sqlalchemy.sql.sqltypes
class BINARY(_Binary)
| BINARY(length: 'Optional[int]' = None)
|
| The SQL BINARY type.
|
| Method resolution order:
| BINARY
| _Binary
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'BINARY'
|
| ----------------------------------------------------------------------
| Methods inherited from _Binary:
|
| __init__(self, length: 'Optional[int]' = None)
| Initialize self. See help(type(self)) for accurate signature.
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op, value)
| See :meth:`.TypeEngine.coerce_compared_value` for a description.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from _Binary:
|
| 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.
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeEngine.Comparator'>
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| comparator_factory = <class 'sqlalchemy.sql.type_api.TypeEngine.Compar...
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| Function to initialize subclasses.
sqlmodel.BLANK_SCHEMA
Python Library Documentation: SchemaConst in module sqlalchemy.sql.schema object class SchemaConst(enum.Enum) | SchemaConst(*values) | | Method resolution order: | SchemaConst | enum.Enum | builtins.object | | Data and other attributes defined here: | | BLANK_SCHEMA = <SchemaConst.BLANK_SCHEMA: 2> | | NULL_UNSPECIFIED = <SchemaConst.NULL_UNSPECIFIED: 3> | | RETAIN_SCHEMA = <SchemaConst.RETAIN_SCHEMA: 1> | | ---------------------------------------------------------------------- | Data descriptors inherited from enum.Enum: | | name | The name of the Enum member. | | value | The value of the Enum member. | | ---------------------------------------------------------------------- | Static methods inherited from enum.EnumType: | | __contains__(value) | Return True if `value` is in `cls`. | | `value` is in `cls` if: | 1) `value` is a member of `cls`, or | 2) `value` is the value of one of the `cls`'s members. | | __getitem__(name) | Return the member matching `name`. | | __iter__() | Return members in definition order. | | __len__() | Return the number of members (no aliases) | | ---------------------------------------------------------------------- | Readonly properties inherited from enum.EnumType: | | __members__ | Returns a mapping of member name->value. | | This mapping lists all enum members, including aliases. Note that this | is a read-only view of the internal mapping.
sqlmodel.BLOB
Python Library Documentation: class BLOB in module sqlalchemy.sql.sqltypes
class BLOB(LargeBinary)
| BLOB(length: 'Optional[int]' = None)
|
| The SQL BLOB type.
|
| Method resolution order:
| BLOB
| LargeBinary
| _Binary
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'BLOB'
|
| ----------------------------------------------------------------------
| Methods inherited from LargeBinary:
|
| __init__(self, length: 'Optional[int]' = None)
| Construct a LargeBinary type.
|
| :param length: optional, a length for the column for use in
| DDL statements, for those binary types that accept a length,
| such as the MySQL BLOB type.
|
| ----------------------------------------------------------------------
| Methods inherited from _Binary:
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op, value)
| See :meth:`.TypeEngine.coerce_compared_value` for a description.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from _Binary:
|
| 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.
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeEngine.Comparator'>
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| comparator_factory = <class 'sqlalchemy.sql.type_api.TypeEngine.Compar...
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| Function to initialize subclasses.
sqlmodel.BOOLEAN
Python Library Documentation: class BOOLEAN in module sqlalchemy.sql.sqltypes
class BOOLEAN(Boolean)
| BOOLEAN(create_constraint: 'bool' = False, name: 'Optional[str]' = None, _create_events: 'bool' = True, _adapted_from: 'Optional[SchemaType]' = None)
|
| The SQL BOOLEAN type.
|
| Method resolution order:
| BOOLEAN
| Boolean
| SchemaType
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.type_api.Emulated
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'BOOLEAN'
|
| ----------------------------------------------------------------------
| Methods inherited from Boolean:
|
| __init__(self, create_constraint: 'bool' = False, name: 'Optional[str]' = None, _create_events: 'bool' = True, _adapted_from: 'Optional[SchemaType]' = None)
| 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.
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| copy(self, **kw)
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Boolean:
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Boolean:
|
| native = True
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaType:
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
|
| create(self, bind: '_CreateDropBind', checkfirst: 'bool' = False) -> 'None'
| Issue CREATE DDL for this type, if applicable.
|
| drop(self, bind: '_CreateDropBind', checkfirst: 'bool' = False) -> 'None'
| Issue DROP DDL for this type, if applicable.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.Emulated:
|
| adapt_to_emulated(self, impltype: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| Given an impl class, adapt this type to the impl assuming
| "emulated".
|
| The impl should also be an "emulated" version of this type,
| most likely the same class as this type itself.
|
| e.g.: sqltypes.Enum adapts to the Enum class.
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| get_dbapi_type(self, dbapi: 'DBAPIModule') -> 'Optional[Any]'
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeEngine.Comparator'>
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| comparator_factory = <class 'sqlalchemy.sql.type_api.TypeEngine.Compar...
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.BigInteger
Python Library Documentation: class BigInteger in module sqlalchemy.sql.sqltypes
class BigInteger(Integer)
| A type for bigger ``int`` integers.
|
| Typically generates a ``BIGINT`` in DDL, and otherwise acts like
| a normal :class:`.Integer` on the Python side.
|
| Method resolution order:
| BigInteger
| Integer
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'big_integer'
|
| ----------------------------------------------------------------------
| Methods inherited from Integer:
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Integer:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Boolean
Python Library Documentation: class Boolean in module sqlalchemy.sql.sqltypes
class Boolean(SchemaType, sqlalchemy.sql.type_api.Emulated, sqlalchemy.sql.type_api.TypeEngine)
| Boolean(create_constraint: 'bool' = False, name: 'Optional[str]' = None, _create_events: 'bool' = True, _adapted_from: 'Optional[SchemaType]' = None)
|
| 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 resolution order:
| Boolean
| SchemaType
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.type_api.Emulated
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, create_constraint: 'bool' = False, name: 'Optional[str]' = None, _create_events: 'bool' = True, _adapted_from: 'Optional[SchemaType]' = None)
| 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.
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| copy(self, **kw)
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'boolean'
|
| native = True
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaType:
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
|
| create(self, bind: '_CreateDropBind', checkfirst: 'bool' = False) -> 'None'
| Issue CREATE DDL for this type, if applicable.
|
| drop(self, bind: '_CreateDropBind', checkfirst: 'bool' = False) -> 'None'
| Issue DROP DDL for this type, if applicable.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.Emulated:
|
| adapt_to_emulated(self, impltype: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| Given an impl class, adapt this type to the impl assuming
| "emulated".
|
| The impl should also be an "emulated" version of this type,
| most likely the same class as this type itself.
|
| e.g.: sqltypes.Enum adapts to the Enum class.
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| get_dbapi_type(self, dbapi: 'DBAPIModule') -> 'Optional[Any]'
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeEngine.Comparator'>
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| comparator_factory = <class 'sqlalchemy.sql.type_api.TypeEngine.Compar...
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.CHAR
Python Library Documentation: class CHAR in module sqlalchemy.sql.sqltypes
class CHAR(String)
| CHAR(length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
|
| The SQL CHAR type.
|
| Method resolution order:
| CHAR
| String
| Concatenable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'CHAR'
|
| ----------------------------------------------------------------------
| Methods inherited from String:
|
| __init__(self, length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
| Create a string-holding type.
|
| :param length: optional, a length for the column for use in
| DDL and CAST expressions. May be safely omitted if no ``CREATE
| TABLE`` will be issued. Certain databases may require a
| ``length`` for use in DDL, and will raise an exception when
| the ``CREATE TABLE`` DDL is issued if a ``VARCHAR``
| with no length is included. Whether the value is
| interpreted as bytes or characters is database specific.
|
| :param collation: Optional, a column-level collation for
| use in DDL and CAST expressions. Renders using the
| COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
| E.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> from sqlalchemy import cast, select, String
| >>> print(select(cast("some string", String(collation="utf8"))))
| {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
|
| .. note::
|
| In most cases, the :class:`.Unicode` or :class:`.UnicodeText`
| datatypes should be used for a :class:`_schema.Column` that expects
| to store non-ascii data. These datatypes will ensure that the
| correct types are used on the database.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from String:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Concatenable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Concatenable:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comparator'>
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comp...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.CLOB
Python Library Documentation: class CLOB in module sqlalchemy.sql.sqltypes
class CLOB(Text)
| CLOB(length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
|
| The CLOB type.
|
| This type is found in Oracle Database and Informix.
|
| Method resolution order:
| CLOB
| Text
| String
| Concatenable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'CLOB'
|
| ----------------------------------------------------------------------
| Methods inherited from String:
|
| __init__(self, length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
| Create a string-holding type.
|
| :param length: optional, a length for the column for use in
| DDL and CAST expressions. May be safely omitted if no ``CREATE
| TABLE`` will be issued. Certain databases may require a
| ``length`` for use in DDL, and will raise an exception when
| the ``CREATE TABLE`` DDL is issued if a ``VARCHAR``
| with no length is included. Whether the value is
| interpreted as bytes or characters is database specific.
|
| :param collation: Optional, a column-level collation for
| use in DDL and CAST expressions. Renders using the
| COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
| E.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> from sqlalchemy import cast, select, String
| >>> print(select(cast("some string", String(collation="utf8"))))
| {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
|
| .. note::
|
| In most cases, the :class:`.Unicode` or :class:`.UnicodeText`
| datatypes should be used for a :class:`_schema.Column` that expects
| to store non-ascii data. These datatypes will ensure that the
| correct types are used on the database.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from String:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Concatenable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Concatenable:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comparator'>
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comp...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.CheckConstraint
Python Library Documentation: class CheckConstraint in module sqlalchemy.sql.schema
class CheckConstraint(ColumnCollectionConstraint)
| CheckConstraint(sqltext: '_TextCoercedExpressionArgument[Any]', name: '_ConstraintNameArgument' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, table: 'Optional[Table]' = None, info: 'Optional[_InfoType]' = None, _create_rule: 'Optional[Any]' = None, _autoattach: 'bool' = True, _type_bound: 'bool' = False, **dialect_kw: 'Any') -> 'None'
|
| A table- or column-level CHECK constraint.
|
| Can be included in the definition of a Table or Column.
|
| Method resolution order:
| CheckConstraint
| ColumnCollectionConstraint
| ColumnCollectionMixin
| Constraint
| sqlalchemy.sql.base.DialectKWArgs
| HasConditionalDDL
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __init__(self, sqltext: '_TextCoercedExpressionArgument[Any]', name: '_ConstraintNameArgument' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, table: 'Optional[Table]' = None, info: 'Optional[_InfoType]' = None, _create_rule: 'Optional[Any]' = None, _autoattach: 'bool' = True, _type_bound: 'bool' = False, **dialect_kw: 'Any') -> 'None'
| Construct a CHECK constraint.
|
| :param sqltext:
| A string containing the constraint definition, which will be used
| verbatim, or a SQL expression construct. If given as a string,
| the object is converted to a :func:`_expression.text` object.
| If the textual
| string includes a colon character, escape this using a backslash::
|
| CheckConstraint(r"foo ~ E'a(?\:b|c)d")
|
| .. warning:: The :paramref:`.CheckConstraint.sqltext` argument to :class:`.CheckConstraint` can be passed as a Python string argument, which will be treated as **trusted SQL text** and rendered as given. **DO NOT PASS UNTRUSTED INPUT TO THIS PARAMETER**.
|
|
|
| :param name:
| Optional, the in-database name of the constraint.
|
| :param deferrable:
| Optional bool. If set, emit DEFERRABLE or NOT DEFERRABLE when
| issuing DDL for this constraint.
|
| :param initially:
| Optional string. If set, emit INITIALLY <value> when issuing DDL
| for this constraint.
|
| :param info: Optional data dictionary which will be populated into the
| :attr:`.SchemaItem.info` attribute of this object.
|
| copy(self, *, target_table: 'Optional[Table]' = None, **kw: 'Any') -> 'CheckConstraint'
| .. deprecated:: 1.4 The :meth:`_schema.CheckConstraint.copy` method is deprecated and will be removed in a future release.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| is_column_level
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __visit_name__ = 'table_or_column_check_constraint'
|
| ----------------------------------------------------------------------
| Methods inherited from ColumnCollectionConstraint:
|
| __contains__(self, x: 'Any') -> 'bool'
|
| __iter__(self) -> 'Iterator[Column[Any]]'
|
| __len__(self) -> 'int'
|
| contains_column(self, col: 'Column[Any]') -> 'bool'
| Return True if this constraint contains the given column.
|
| Note that this object also contains an attribute ``.columns``
| which is a :class:`_expression.ColumnCollection` of
| :class:`_schema.Column` objects.
|
| ----------------------------------------------------------------------
| Methods inherited from ColumnCollectionMixin:
|
| c(...)
|
| columns(...)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ColumnCollectionMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Constraint:
|
| table
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_options(...)
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| This is a two-level nested registry, keyed to ``<dialect_name>``
| and ``<argument_name>``. For example, the ``postgresql_where``
| argument would be locatable as::
|
| arg = my_object.dialect_options["postgresql"]["where"]
|
| .. versionadded:: 0.9.2
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form
|
| get_dialect_option(self, dialect: 'Dialect', argument_name: 'str', *, else_: 'Any' = None, deprecated_fallback: 'Optional[str]' = None) -> 'Any'
| Return the value of a dialect-specific option, or *else_* if
| this dialect does not register the given argument.
|
| This is useful for DDL compilers that may be inherited by
| third-party dialects whose ``construct_arguments`` do not
| include the same set of keys as the parent dialect.
|
| :param dialect: The dialect for which to retrieve the option.
| :param argument_name: The name of the argument to retrieve.
| :param else\_: The value to return if the argument is not present.
| :param deprecated_fallback: Optional dialect name to fall back to
| if the argument is not present for the current dialect. If the
| argument is present for the fallback dialect but not the current
| dialect, a deprecation warning will be emitted.
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| argument_for(dialect_name: 'str', argument_name: 'str', default: 'Any') -> 'None'
| Add a new kind of dialect-specific keyword argument for this class.
|
| E.g.::
|
| Index.argument_for("mydialect", "length", None)
|
| some_index = Index("a", "b", mydialect_length=5)
|
| The :meth:`.DialectKWArgs.argument_for` method is a per-argument
| way adding extra arguments to the
| :attr:`.DefaultDialect.construct_arguments` dictionary. This
| dictionary provides a list of argument names accepted by various
| schema-level constructs on behalf of a dialect.
|
| New dialects should typically specify this dictionary all at once as a
| data member of the dialect class. The use case for ad-hoc addition of
| argument names is typically for end-user code that is also using
| a custom compilation scheme which consumes the additional arguments.
|
| :param dialect_name: name of a dialect. The dialect must be
| locatable, else a :class:`.NoSuchModuleError` is raised. The
| dialect must also include an existing
| :attr:`.DefaultDialect.construct_arguments` collection, indicating
| that it participates in the keyword-argument validation and default
| system, else :class:`.ArgumentError` is raised. If the dialect does
| not include this collection, then any keyword argument can be
| specified on behalf of this dialect already. All dialects packaged
| within SQLAlchemy include this collection, however for third party
| dialects, support may vary.
|
| :param argument_name: name of the parameter.
|
| :param default: default value of the parameter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_kwargs
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| The arguments are present here in their original ``<dialect>_<kwarg>``
| format. Only arguments that were actually passed are included;
| unlike the :attr:`.DialectKWArgs.dialect_options` collection, which
| contains all options known by this dialect including defaults.
|
| The collection is also writable; keys are accepted of the
| form ``<dialect>_<kwarg>`` where the value will be assembled
| into the list of options.
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_options` - nested dictionary form
|
| kwargs
| A synonym for :attr:`.DialectKWArgs.dialect_kwargs`.
|
| ----------------------------------------------------------------------
| Methods inherited from HasConditionalDDL:
|
| ddl_if(self, dialect: 'Optional[str]' = None, callable_: 'Optional[ddl.DDLIfCallable]' = None, state: 'Optional[Any]' = None) -> 'Self'
| apply a conditional DDL rule to this schema item.
|
| These rules work in a similar manner to the
| :meth:`.ExecutableDDLElement.execute_if` callable, with the added
| feature that the criteria may be checked within the DDL compilation
| phase for a construct such as :class:`.CreateTable`.
| :meth:`.HasConditionalDDL.ddl_if` currently applies towards the
| :class:`.Index` construct as well as all :class:`.Constraint`
| constructs.
|
| :param dialect: string name of a dialect, or a tuple of string names
| to indicate multiple dialect types.
|
| :param callable\_: a callable that is constructed using the same form
| as that described in
| :paramref:`.ExecutableDDLElement.execute_if.callable_`.
|
| :param state: any arbitrary object that will be passed to the
| callable, if present.
|
| .. versionadded:: 2.0
|
| .. seealso::
|
| :ref:`schema_ddl_ddl_if` - background and usage examples
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Column
Python Library Documentation: class Column in module sqlalchemy.sql.schema
class Column(sqlalchemy.sql.base.DialectKWArgs, SchemaItem, sqlalchemy.sql.elements.ColumnClause)
| Column(_Column__name_pos: 'Optional[Union[str, _TypeEngineArgument[_T], SchemaEventTarget]]' = None, _Column__type_pos: 'Optional[Union[_TypeEngineArgument[_T], SchemaEventTarget]]' = None, *args: 'SchemaEventTarget', name: 'Optional[str]' = None, type_: 'Optional[_TypeEngineArgument[_T]]' = None, autoincrement: '_AutoIncrementType' = 'auto', default: 'Optional[Any]' = _NoArg.NO_ARG, insert_default: 'Optional[Any]' = _NoArg.NO_ARG, doc: 'Optional[str]' = None, key: 'Optional[str]' = None, index: 'Optional[bool]' = None, unique: 'Optional[bool]' = None, info: 'Optional[_InfoType]' = None, nullable: 'Optional[Union[bool, Literal[SchemaConst.NULL_UNSPECIFIED]]]' = <SchemaConst.NULL_UNSPECIFIED: 3>, onupdate: 'Optional[Any]' = None, primary_key: 'bool' = False, server_default: 'Optional[_ServerDefaultArgument]' = None, server_onupdate: 'Optional[_ServerOnUpdateArgument]' = None, quote: 'Optional[bool]' = None, system: 'bool' = False, comment: 'Optional[str]' = None, insert_sentinel: 'bool' = False, _omit_from_statements: 'bool' = False, _proxies: 'Optional[Any]' = None, **dialect_kwargs: 'Any')
|
| Represents a column in a database table.
|
| Method resolution order:
| Column
| sqlalchemy.sql.base.DialectKWArgs
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.elements.ColumnClause
| sqlalchemy.sql.roles.DDLReferredColumnRole
| sqlalchemy.sql.roles.LabeledColumnExprRole
| sqlalchemy.sql.roles.StrAsPlainColumnRole
| sqlalchemy.sql.base.Immutable
| sqlalchemy.sql.elements.NamedColumn
| sqlalchemy.sql.elements.KeyedColumnElement
| sqlalchemy.sql.elements.ColumnElement
| sqlalchemy.sql.roles.ColumnArgumentOrKeyRole
| sqlalchemy.sql.roles.ColumnArgumentRole
| sqlalchemy.sql.roles.StatementOptionRole
| sqlalchemy.sql.roles.WhereHavingRole
| sqlalchemy.sql.roles.OnClauseRole
| sqlalchemy.sql.roles.BinaryElementRole
| sqlalchemy.sql.roles.OrderByRole
| sqlalchemy.sql.roles.ColumnsClauseRole
| sqlalchemy.sql.roles.AllowsLambdaRole
| sqlalchemy.sql.roles.ByOfRole
| sqlalchemy.sql.roles.UsesInspection
| sqlalchemy.sql.roles.ColumnListRole
| sqlalchemy.sql.roles.LimitOffsetRole
| sqlalchemy.sql.roles.DMLColumnRole
| sqlalchemy.sql.roles.DDLConstraintColumnRole
| sqlalchemy.sql.roles.DDLExpressionRole
| sqlalchemy.sql.roles.StructuralRole
| sqlalchemy.sql.elements.SQLColumnExpression
| sqlalchemy.sql.elements.SQLCoreOperations
| sqlalchemy.sql.roles.ExpressionElementRole
| sqlalchemy.sql.roles.TypedColumnsClauseRole
| typing.Generic
| sqlalchemy.sql.operators.ColumnOperators
| sqlalchemy.sql.operators.Operators
| sqlalchemy.util.langhelpers.TypingOnly
| sqlalchemy.sql.roles.SQLRole
| sqlalchemy.sql.elements.DQLDMLClauseElement
| sqlalchemy.sql.elements.ClauseElement
| sqlalchemy.sql.annotation.SupportsWrappingAnnotations
| sqlalchemy.sql.annotation.SupportsAnnotations
| sqlalchemy.sql.cache_key.MemoizedHasCacheKey
| sqlalchemy.sql.cache_key.HasCacheKey
| sqlalchemy.util.langhelpers.HasMemoized
| sqlalchemy.sql.traversals.HasCopyInternals
| sqlalchemy.sql.visitors.ExternallyTraversible
| sqlalchemy.sql.visitors.HasTraverseInternals
| sqlalchemy.sql.elements.CompilerElement
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __init__(self, _Column__name_pos: 'Optional[Union[str, _TypeEngineArgument[_T], SchemaEventTarget]]' = None, _Column__type_pos: 'Optional[Union[_TypeEngineArgument[_T], SchemaEventTarget]]' = None, *args: 'SchemaEventTarget', name: 'Optional[str]' = None, type_: 'Optional[_TypeEngineArgument[_T]]' = None, autoincrement: '_AutoIncrementType' = 'auto', default: 'Optional[Any]' = _NoArg.NO_ARG, insert_default: 'Optional[Any]' = _NoArg.NO_ARG, doc: 'Optional[str]' = None, key: 'Optional[str]' = None, index: 'Optional[bool]' = None, unique: 'Optional[bool]' = None, info: 'Optional[_InfoType]' = None, nullable: 'Optional[Union[bool, Literal[SchemaConst.NULL_UNSPECIFIED]]]' = <SchemaConst.NULL_UNSPECIFIED: 3>, onupdate: 'Optional[Any]' = None, primary_key: 'bool' = False, server_default: 'Optional[_ServerDefaultArgument]' = None, server_onupdate: 'Optional[_ServerOnUpdateArgument]' = None, quote: 'Optional[bool]' = None, system: 'bool' = False, comment: 'Optional[str]' = None, insert_sentinel: 'bool' = False, _omit_from_statements: 'bool' = False, _proxies: 'Optional[Any]' = None, **dialect_kwargs: 'Any')
| Construct a new ``Column`` object.
|
| :param name: The name of this column as represented in the database.
| This argument may be the first positional argument, or specified
| via keyword.
|
| Names which contain no upper case characters
| will be treated as case insensitive names, and will not be quoted
| unless they are a reserved word. Names with any number of upper
| case characters will be quoted and sent exactly. Note that this
| behavior applies even for databases which standardize upper
| case names as case insensitive such as Oracle Database.
|
| The name field may be omitted at construction time and applied
| later, at any time before the Column is associated with a
| :class:`_schema.Table`. This is to support convenient
| usage within the :mod:`~sqlalchemy.ext.declarative` extension.
|
| :param type\_: The column's type, indicated using an instance which
| subclasses :class:`~sqlalchemy.types.TypeEngine`. If no arguments
| are required for the type, the class of the type can be sent
| as well, e.g.::
|
| # use a type with arguments
| Column("data", String(50))
|
| # use no arguments
| Column("level", Integer)
|
| The ``type`` argument may be the second positional argument
| or specified by keyword.
|
| If the ``type`` is ``None`` or is omitted, it will first default to
| the special type :class:`.NullType`. If and when this
| :class:`_schema.Column` is made to refer to another column using
| :class:`_schema.ForeignKey` and/or
| :class:`_schema.ForeignKeyConstraint`, the type
| of the remote-referenced column will be copied to this column as
| well, at the moment that the foreign key is resolved against that
| remote :class:`_schema.Column` object.
|
| :param \*args: Additional positional arguments include various
| :class:`.SchemaItem` derived constructs which will be applied
| as options to the column. These include instances of
| :class:`.Constraint`, :class:`_schema.ForeignKey`,
| :class:`.ColumnDefault`, :class:`.Sequence`, :class:`.Computed`
| :class:`.Identity`. In some cases an
| equivalent keyword argument is available such as ``server_default``,
| ``default`` and ``unique``.
|
| :param autoincrement: Set up "auto increment" semantics for an
| **integer primary key column with no foreign key dependencies**
| (see later in this docstring for a more specific definition).
| This may influence the :term:`DDL` that will be emitted for
| this column during a table create, as well as how the column
| will be considered when INSERT statements are compiled and
| executed.
|
| The default value is the string ``"auto"``,
| which indicates that a single-column (i.e. non-composite) primary key
| that is of an INTEGER type with no other client-side or server-side
| default constructs indicated should receive auto increment semantics
| automatically. Other values include ``True`` (force this column to
| have auto-increment semantics for a :term:`composite primary key` as
| well), ``False`` (this column should never have auto-increment
| semantics), and the string ``"ignore_fk"`` (special-case for foreign
| key columns, see below).
|
| The term "auto increment semantics" refers both to the kind of DDL
| that will be emitted for the column within a CREATE TABLE statement,
| when methods such as :meth:`.MetaData.create_all` and
| :meth:`.Table.create` are invoked, as well as how the column will be
| considered when an INSERT statement is compiled and emitted to the
| database:
|
| * **DDL rendering** (i.e. :meth:`.MetaData.create_all`,
| :meth:`.Table.create`): When used on a :class:`.Column` that has
| no other
| default-generating construct associated with it (such as a
| :class:`.Sequence` or :class:`.Identity` construct), the parameter
| will imply that database-specific keywords such as PostgreSQL
| ``SERIAL``, MySQL ``AUTO_INCREMENT``, or ``IDENTITY`` on SQL Server
| should also be rendered. Not every database backend has an
| "implied" default generator available; for example the Oracle Database
| backends always needs an explicit construct such as
| :class:`.Identity` to be included with a :class:`.Column` in order
| for the DDL rendered to include auto-generating constructs to also
| be produced in the database.
|
| * **INSERT semantics** (i.e. when a :func:`_sql.insert` construct is
| compiled into a SQL string and is then executed on a database using
| :meth:`_engine.Connection.execute` or equivalent): A single-row
| INSERT statement will be known to produce a new integer primary key
| value automatically for this column, which will be accessible
| after the statement is invoked via the
| :attr:`.CursorResult.inserted_primary_key` attribute upon the
| :class:`_result.Result` object. This also applies towards use of the
| ORM when ORM-mapped objects are persisted to the database,
| indicating that a new integer primary key will be available to
| become part of the :term:`identity key` for that object. This
| behavior takes place regardless of what DDL constructs are
| associated with the :class:`_schema.Column` and is independent
| of the "DDL Rendering" behavior discussed in the previous note
| above.
|
| The parameter may be set to ``True`` to indicate that a column which
| is part of a composite (i.e. multi-column) primary key should
| have autoincrement semantics, though note that only one column
| within a primary key may have this setting. It can also
| be set to ``True`` to indicate autoincrement semantics on a
| column that has a client-side or server-side default configured,
| however note that not all dialects can accommodate all styles
| of default as an "autoincrement". It can also be
| set to ``False`` on a single-column primary key that has a
| datatype of INTEGER in order to disable auto increment semantics
| for that column.
|
| The setting *only* has an effect for columns which are:
|
| * Integer derived (i.e. INT, SMALLINT, BIGINT).
|
| * Part of the primary key
|
| * Not referring to another column via :class:`_schema.ForeignKey`,
| unless
| the value is specified as ``'ignore_fk'``::
|
| # turn on autoincrement for this column despite
| # the ForeignKey()
| Column(
| "id",
| ForeignKey("other.id"),
| primary_key=True,
| autoincrement="ignore_fk",
| )
|
| It is typically not desirable to have "autoincrement" enabled on a
| column that refers to another via foreign key, as such a column is
| required to refer to a value that originates from elsewhere.
|
| The setting has these effects on columns that meet the
| above criteria:
|
| * DDL issued for the column, if the column does not already include
| a default generating construct supported by the backend such as
| :class:`.Identity`, will include database-specific
| keywords intended to signify this column as an
| "autoincrement" column for specific backends. Behavior for
| primary SQLAlchemy dialects includes:
|
| * AUTO INCREMENT on MySQL and MariaDB
| * SERIAL on PostgreSQL
| * IDENTITY on MS-SQL - this occurs even without the
| :class:`.Identity` construct as the
| :paramref:`.Column.autoincrement` parameter pre-dates this
| construct.
| * SQLite - SQLite integer primary key columns are implicitly
| "auto incrementing" and no additional keywords are rendered;
| to render the special SQLite keyword ``AUTOINCREMENT``
| is not included as this is unnecessary and not recommended
| by the database vendor. See the section
| :ref:`sqlite_autoincrement` for more background.
| * Oracle Database - The Oracle Database dialects have no default "autoincrement"
| feature available at this time, instead the :class:`.Identity`
| construct is recommended to achieve this (the :class:`.Sequence`
| construct may also be used).
| * Third-party dialects - consult those dialects' documentation
| for details on their specific behaviors.
|
| * When a single-row :func:`_sql.insert` construct is compiled and
| executed, which does not set the :meth:`_sql.Insert.inline`
| modifier, newly generated primary key values for this column
| will be automatically retrieved upon statement execution
| using a method specific to the database driver in use:
|
| * MySQL, SQLite - calling upon ``cursor.lastrowid()``
| (see
| `https://www.python.org/dev/peps/pep-0249/#lastrowid
| <https://www.python.org/dev/peps/pep-0249/#lastrowid>`_)
| * PostgreSQL, SQL Server, Oracle Database - use RETURNING or an equivalent
| construct when rendering an INSERT statement, and then retrieving
| the newly generated primary key values after execution
| * PostgreSQL, Oracle Database for :class:`_schema.Table` objects that
| set :paramref:`_schema.Table.implicit_returning` to False -
| for a :class:`.Sequence` only, the :class:`.Sequence` is invoked
| explicitly before the INSERT statement takes place so that the
| newly generated primary key value is available to the client
| * SQL Server for :class:`_schema.Table` objects that
| set :paramref:`_schema.Table.implicit_returning` to False -
| the ``SELECT scope_identity()`` construct is used after the
| INSERT statement is invoked to retrieve the newly generated
| primary key value.
| * Third-party dialects - consult those dialects' documentation
| for details on their specific behaviors.
|
| * For multiple-row :func:`_sql.insert` constructs invoked with
| a list of parameters (i.e. "executemany" semantics), primary-key
| retrieving behaviors are generally disabled, however there may
| be special APIs that may be used to retrieve lists of new
| primary key values for an "executemany", such as the psycopg2
| "fast insertmany" feature. Such features are very new and
| may not yet be well covered in documentation.
|
| :param default: A scalar, Python callable, or
| :class:`_expression.ColumnElement` expression representing the
| *default value* for this column, which will be invoked upon insert
| if this column is otherwise not specified in the VALUES clause of
| the insert. This is a shortcut to using :class:`.ColumnDefault` as
| a positional argument; see that class for full detail on the
| structure of the argument.
|
| Contrast this argument to
| :paramref:`_schema.Column.server_default`
| which creates a default generator on the database side.
|
| .. seealso::
|
| :ref:`metadata_defaults_toplevel`
|
| :param insert_default: An alias of :paramref:`.Column.default`
| for compatibility with :func:`_orm.mapped_column`.
|
| .. versionadded: 2.0.31
|
| :param doc: optional String that can be used by the ORM or similar
| to document attributes on the Python side. This attribute does
| **not** render SQL comments; use the
| :paramref:`_schema.Column.comment`
| parameter for this purpose.
|
| :param key: An optional string identifier which will identify this
| ``Column`` object on the :class:`_schema.Table`.
| When a key is provided,
| this is the only identifier referencing the ``Column`` within the
| application, including ORM attribute mapping; the ``name`` field
| is used only when rendering SQL.
|
| :param index: When ``True``, indicates that a :class:`_schema.Index`
| construct will be automatically generated for this
| :class:`_schema.Column`, which will result in a "CREATE INDEX"
| statement being emitted for the :class:`_schema.Table` when the DDL
| create operation is invoked.
|
| Using this flag is equivalent to making use of the
| :class:`_schema.Index` construct explicitly at the level of the
| :class:`_schema.Table` construct itself::
|
| Table(
| "some_table",
| metadata,
| Column("x", Integer),
| Index("ix_some_table_x", "x"),
| )
|
| To add the :paramref:`_schema.Index.unique` flag to the
| :class:`_schema.Index`, set both the
| :paramref:`_schema.Column.unique` and
| :paramref:`_schema.Column.index` flags to True simultaneously,
| which will have the effect of rendering the "CREATE UNIQUE INDEX"
| DDL instruction instead of "CREATE INDEX".
|
| The name of the index is generated using the
| :ref:`default naming convention <constraint_default_naming_convention>`
| which for the :class:`_schema.Index` construct is of the form
| ``ix_<tablename>_<columnname>``.
|
| As this flag is intended only as a convenience for the common case
| of adding a single-column, default configured index to a table
| definition, explicit use of the :class:`_schema.Index` construct
| should be preferred for most use cases, including composite indexes
| that encompass more than one column, indexes with SQL expressions
| or ordering, backend-specific index configuration options, and
| indexes that use a specific name.
|
| .. note:: the :attr:`_schema.Column.index` attribute on
| :class:`_schema.Column`
| **does not indicate** if this column is indexed or not, only
| if this flag was explicitly set here. To view indexes on
| a column, view the :attr:`_schema.Table.indexes` collection
| or use :meth:`_reflection.Inspector.get_indexes`.
|
| .. seealso::
|
| :ref:`schema_indexes`
|
| :ref:`constraint_naming_conventions`
|
| :paramref:`_schema.Column.unique`
|
| :param info: Optional data dictionary which will be populated into the
| :attr:`.SchemaItem.info` attribute of this object.
|
| :param nullable: When set to ``False``, will cause the "NOT NULL"
| phrase to be added when generating DDL for the column. When
| ``True``, will normally generate nothing (in SQL this defaults to
| "NULL"), except in some very specific backend-specific edge cases
| where "NULL" may render explicitly.
| Defaults to ``True`` unless :paramref:`_schema.Column.primary_key`
| is also ``True`` or the column specifies a :class:`_sql.Identity`,
| in which case it defaults to ``False``.
| This parameter is only used when issuing CREATE TABLE statements.
|
| .. note::
|
| When the column specifies a :class:`_sql.Identity` this
| parameter is in general ignored by the DDL compiler. The
| PostgreSQL database allows nullable identity column by
| setting this parameter to ``True`` explicitly.
|
| :param onupdate: A scalar, Python callable, or
| :class:`~sqlalchemy.sql.expression.ClauseElement` representing a
| default value to be applied to the column within UPDATE
| statements, which will be invoked upon update if this column is not
| present in the SET clause of the update. This is a shortcut to
| using :class:`.ColumnDefault` as a positional argument with
| ``for_update=True``.
|
| .. seealso::
|
| :ref:`metadata_defaults` - complete discussion of onupdate
|
| :param primary_key: If ``True``, marks this column as a primary key
| column. Multiple columns can have this flag set to specify
| composite primary keys. As an alternative, the primary key of a
| :class:`_schema.Table` can be specified via an explicit
| :class:`.PrimaryKeyConstraint` object.
|
| :param server_default: A :class:`.FetchedValue` instance, str, Unicode
| or :func:`~sqlalchemy.sql.expression.text` construct representing
| the DDL DEFAULT value for the column.
|
| String types will be emitted as-is, surrounded by single quotes::
|
| Column("x", Text, server_default="val")
|
| will render:
|
| .. sourcecode:: sql
|
| x TEXT DEFAULT 'val'
|
| A :func:`~sqlalchemy.sql.expression.text` expression will be
| rendered as-is, without quotes::
|
| Column("y", DateTime, server_default=text("NOW()"))
|
| will render:
|
| .. sourcecode:: sql
|
| y DATETIME DEFAULT NOW()
|
| Strings and text() will be converted into a
| :class:`.DefaultClause` object upon initialization.
|
| This parameter can also accept complex combinations of contextually
| valid SQLAlchemy expressions or constructs::
|
| from sqlalchemy import create_engine
| from sqlalchemy import Table, Column, MetaData, ARRAY, Text
| from sqlalchemy.dialects.postgresql import array
|
| engine = create_engine(
| "postgresql+psycopg2://scott:tiger@localhost/mydatabase"
| )
| metadata_obj = MetaData()
| tbl = Table(
| "foo",
| metadata_obj,
| Column(
| "bar", ARRAY(Text), server_default=array(["biz", "bang", "bash"])
| ),
| )
| metadata_obj.create_all(engine)
|
| The above results in a table created with the following SQL:
|
| .. sourcecode:: sql
|
| CREATE TABLE foo (
| bar TEXT[] DEFAULT ARRAY['biz', 'bang', 'bash']
| )
|
| Use :class:`.FetchedValue` to indicate that an already-existing
| column will generate a default value on the database side which
| will be available to SQLAlchemy for post-fetch after inserts. This
| construct does not specify any DDL and the implementation is left
| to the database, such as via a trigger.
|
| .. seealso::
|
| :ref:`server_defaults` - complete discussion of server side
| defaults
|
| :param server_onupdate: A :class:`.FetchedValue` instance
| representing a database-side default generation function,
| such as a trigger. This
| indicates to SQLAlchemy that a newly generated value will be
| available after updates. This construct does not actually
| implement any kind of generation function within the database,
| which instead must be specified separately.
|
|
| .. warning:: This directive **does not** currently produce MySQL's
| "ON UPDATE CURRENT_TIMESTAMP()" clause. See
| :ref:`mysql_timestamp_onupdate` for background on how to
| produce this clause.
|
| .. seealso::
|
| :ref:`triggered_columns`
|
| :param quote: Force quoting of this column's name on or off,
| corresponding to ``True`` or ``False``. When left at its default
| of ``None``, the column identifier will be quoted according to
| whether the name is case sensitive (identifiers with at least one
| upper case character are treated as case sensitive), or if it's a
| reserved word. This flag is only needed to force quoting of a
| reserved word which is not known by the SQLAlchemy dialect.
|
| :param unique: When ``True``, and the :paramref:`_schema.Column.index`
| parameter is left at its default value of ``False``,
| indicates that a :class:`_schema.UniqueConstraint`
| construct will be automatically generated for this
| :class:`_schema.Column`,
| which will result in a "UNIQUE CONSTRAINT" clause referring
| to this column being included
| in the ``CREATE TABLE`` statement emitted, when the DDL create
| operation for the :class:`_schema.Table` object is invoked.
|
| When this flag is ``True`` while the
| :paramref:`_schema.Column.index` parameter is simultaneously
| set to ``True``, the effect instead is that a
| :class:`_schema.Index` construct which includes the
| :paramref:`_schema.Index.unique` parameter set to ``True``
| is generated. See the documentation for
| :paramref:`_schema.Column.index` for additional detail.
|
| Using this flag is equivalent to making use of the
| :class:`_schema.UniqueConstraint` construct explicitly at the
| level of the :class:`_schema.Table` construct itself::
|
| Table("some_table", metadata, Column("x", Integer), UniqueConstraint("x"))
|
| The :paramref:`_schema.UniqueConstraint.name` parameter
| of the unique constraint object is left at its default value
| of ``None``; in the absence of a :ref:`naming convention <constraint_naming_conventions>`
| for the enclosing :class:`_schema.MetaData`, the UNIQUE CONSTRAINT
| construct will be emitted as unnamed, which typically invokes
| a database-specific naming convention to take place.
|
| As this flag is intended only as a convenience for the common case
| of adding a single-column, default configured unique constraint to a table
| definition, explicit use of the :class:`_schema.UniqueConstraint` construct
| should be preferred for most use cases, including composite constraints
| that encompass more than one column, backend-specific index configuration options, and
| constraints that use a specific name.
|
| .. note:: the :attr:`_schema.Column.unique` attribute on
| :class:`_schema.Column`
| **does not indicate** if this column has a unique constraint or
| not, only if this flag was explicitly set here. To view
| indexes and unique constraints that may involve this column,
| view the
| :attr:`_schema.Table.indexes` and/or
| :attr:`_schema.Table.constraints` collections or use
| :meth:`_reflection.Inspector.get_indexes` and/or
| :meth:`_reflection.Inspector.get_unique_constraints`
|
| .. seealso::
|
| :ref:`schema_unique_constraint`
|
| :ref:`constraint_naming_conventions`
|
| :paramref:`_schema.Column.index`
|
| :param system: When ``True``, indicates this is a "system" column,
| that is a column which is automatically made available by the
| database, and should not be included in the columns list for a
| ``CREATE TABLE`` statement.
|
| For more elaborate scenarios where columns should be
| conditionally rendered differently on different backends,
| consider custom compilation rules for :class:`.CreateColumn`.
|
| :param comment: Optional string that will render an SQL comment on
| table creation.
|
| .. versionadded:: 1.2 Added the
| :paramref:`_schema.Column.comment`
| parameter to :class:`_schema.Column`.
|
| :param insert_sentinel: Marks this :class:`_schema.Column` as an
| :term:`insert sentinel` used for optimizing the performance of the
| :term:`insertmanyvalues` feature for tables that don't
| otherwise have qualifying primary key configurations.
|
| .. versionadded:: 2.0.10
|
| .. seealso::
|
| :func:`_schema.insert_sentinel` - all in one helper for declaring
| sentinel columns
|
| :ref:`engine_insertmanyvalues`
|
| :ref:`engine_insertmanyvalues_sentinel_columns`
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| append_foreign_key(self, fk: 'ForeignKey') -> 'None'
|
| copy(self, **kw: 'Any') -> 'Column[Any]'
| .. deprecated:: 1.4 The :meth:`_schema.Column.copy` method is deprecated and will be removed in a future release.
|
| references(self, column: 'Column[Any]') -> 'bool'
| Return True if this Column references the given column via foreign
| key.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'computed': 'Optional[Computed]', 'constraints': 'S...
|
| __orig_bases__ = (<class 'sqlalchemy.sql.base.DialectKWArgs'>, <class ...
|
| __parameters__ = (~_T,)
|
| __visit_name__ = 'column'
|
| inherit_cache = True
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_options(...)
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| This is a two-level nested registry, keyed to ``<dialect_name>``
| and ``<argument_name>``. For example, the ``postgresql_where``
| argument would be locatable as::
|
| arg = my_object.dialect_options["postgresql"]["where"]
|
| .. versionadded:: 0.9.2
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form
|
| get_dialect_option(self, dialect: 'Dialect', argument_name: 'str', *, else_: 'Any' = None, deprecated_fallback: 'Optional[str]' = None) -> 'Any'
| Return the value of a dialect-specific option, or *else_* if
| this dialect does not register the given argument.
|
| This is useful for DDL compilers that may be inherited by
| third-party dialects whose ``construct_arguments`` do not
| include the same set of keys as the parent dialect.
|
| :param dialect: The dialect for which to retrieve the option.
| :param argument_name: The name of the argument to retrieve.
| :param else\_: The value to return if the argument is not present.
| :param deprecated_fallback: Optional dialect name to fall back to
| if the argument is not present for the current dialect. If the
| argument is present for the fallback dialect but not the current
| dialect, a deprecation warning will be emitted.
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| argument_for(dialect_name: 'str', argument_name: 'str', default: 'Any') -> 'None'
| Add a new kind of dialect-specific keyword argument for this class.
|
| E.g.::
|
| Index.argument_for("mydialect", "length", None)
|
| some_index = Index("a", "b", mydialect_length=5)
|
| The :meth:`.DialectKWArgs.argument_for` method is a per-argument
| way adding extra arguments to the
| :attr:`.DefaultDialect.construct_arguments` dictionary. This
| dictionary provides a list of argument names accepted by various
| schema-level constructs on behalf of a dialect.
|
| New dialects should typically specify this dictionary all at once as a
| data member of the dialect class. The use case for ad-hoc addition of
| argument names is typically for end-user code that is also using
| a custom compilation scheme which consumes the additional arguments.
|
| :param dialect_name: name of a dialect. The dialect must be
| locatable, else a :class:`.NoSuchModuleError` is raised. The
| dialect must also include an existing
| :attr:`.DefaultDialect.construct_arguments` collection, indicating
| that it participates in the keyword-argument validation and default
| system, else :class:`.ArgumentError` is raised. If the dialect does
| not include this collection, then any keyword argument can be
| specified on behalf of this dialect already. All dialects packaged
| within SQLAlchemy include this collection, however for third party
| dialects, support may vary.
|
| :param argument_name: name of the parameter.
|
| :param default: default value of the parameter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_kwargs
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| The arguments are present here in their original ``<dialect>_<kwarg>``
| format. Only arguments that were actually passed are included;
| unlike the :attr:`.DialectKWArgs.dialect_options` collection, which
| contains all options known by this dialect including defaults.
|
| The collection is also writable; keys are accepted of the
| form ``<dialect>_<kwarg>`` where the value will be assembled
| into the list of options.
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_options` - nested dictionary form
|
| kwargs
| A synonym for :attr:`.DialectKWArgs.dialect_kwargs`.
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.elements.ColumnClause:
|
| get_children(self, *, column_tables=False, **kw)
| Return immediate child :class:`.visitors.HasTraverseInternals`
| elements of this :class:`.visitors.HasTraverseInternals`.
|
| This is used for visit traversal.
|
| \**kw may contain flags that change the collection that is
| returned, for example to return a subset of items in order to
| cut down on larger traversals, or to return child items from a
| different context (such as schema-level collections instead of
| clause-level).
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.elements.ColumnClause:
|
| entity_namespace
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.elements.ColumnClause:
|
| default = None
|
| onupdate = None
|
| server_default = None
|
| server_onupdate = None
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.Immutable:
|
| params(self, *optionaldict: 'Any', **kwargs: 'Any') -> 'NoReturn'
|
| unique_params(self, *optionaldict: 'Any', **kwargs: 'Any') -> 'NoReturn'
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.elements.NamedColumn:
|
| description(...)
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.elements.NamedColumn:
|
| is_literal = False
|
| table = None
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.elements.ColumnElement:
|
| __getattr__(self, key: 'str') -> 'Any'
|
| __setstate__(self, state)
|
| base_columns(...)
|
| cast(self, type_: '_TypeEngineArgument[_OPT]') -> 'Cast[_OPT]'
| Produce a type cast, i.e. ``CAST(<expression> AS <type>)``.
|
| This is a shortcut to the :func:`_expression.cast` function.
|
| .. seealso::
|
| :ref:`tutorial_casts`
|
| :func:`_expression.cast`
|
| :func:`_expression.type_coerce`
|
| comparator(...)
|
| label(self, name: 'Optional[str]') -> 'Label[_T]'
| Produce a column label, i.e. ``<columnname> AS <name>``.
|
| This is a shortcut to the :func:`_expression.label` function.
|
| If 'name' is ``None``, an anonymous label name will be generated.
|
| operate(self, op: 'operators.OperatorType', *other: 'Any', **kwargs: 'Any') -> 'ColumnElement[Any]'
| Operate on an argument.
|
| This is the lowest level of operation, raises
| :class:`NotImplementedError` by default.
|
| Overriding this on a subclass can allow common
| behavior to be applied to all operations.
| For example, overriding :class:`.ColumnOperators`
| to apply ``func.lower()`` to the left and right
| side::
|
| class MyComparator(ColumnOperators):
| def operate(self, op, other, **kwargs):
| return op(func.lower(self), func.lower(other), **kwargs)
|
| :param op: Operator callable.
| :param \*other: the 'other' side of the operation. Will
| be a single scalar for most operations.
| :param \**kwargs: modifiers. These may be passed by special
| operators such as :meth:`ColumnOperators.contains`.
|
| proxy_set(...)
| set of all columns we are proxying
|
| as of 2.0 this is explicitly deannotated columns. previously it was
| effectively deannotated columns but wasn't enforced. annotated
| columns should basically not go into sets if at all possible because
| their hashing behavior is very non-performant.
|
| reverse_operate(self, op: 'operators.OperatorType', other: 'Any', **kwargs: 'Any') -> 'ColumnElement[Any]'
| Reverse operate on an argument.
|
| Usage is the same as :meth:`operate`.
|
| self_group(self, against: 'Optional[OperatorType]' = None) -> 'ColumnElement[Any]'
| Apply a 'grouping' to this :class:`_expression.ClauseElement`.
|
| This method is overridden by subclasses to return a "grouping"
| construct, i.e. parenthesis. In particular it's used by "binary"
| expressions to provide a grouping around themselves when placed into a
| larger expression, as well as by :func:`_expression.select`
| constructs when placed into the FROM clause of another
| :func:`_expression.select`. (Note that subqueries should be
| normally created using the :meth:`_expression.Select.alias` method,
| as many
| platforms require nested SELECT statements to be named).
|
| As expressions are composed together, the application of
| :meth:`self_group` is automatic - end-user code should never
| need to use this method directly. Note that SQLAlchemy's
| clause constructs take operator precedence into account -
| so parenthesis might not be needed, for example, in
| an expression like ``x OR (y AND z)`` - AND takes precedence
| over OR.
|
| The base :meth:`self_group` method of
| :class:`_expression.ClauseElement`
| just returns self.
|
| shares_lineage(self, othercolumn: 'ColumnElement[Any]') -> 'bool'
| Return True if the given :class:`_expression.ColumnElement`
| has a common ancestor to this :class:`_expression.ColumnElement`.
|
| type(...)
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.elements.ColumnElement:
|
| anon_key_label
| .. deprecated:: 1.4 The :attr:`_expression.ColumnElement.anon_key_label` attribute is now private, and the public accessor is deprecated.
|
| anon_label
| .. deprecated:: 1.4 The :attr:`_expression.ColumnElement.anon_label` attribute is now private, and the public accessor is deprecated.
|
| expression
| Return a column expression.
|
| Part of the inspection interface; returns self.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.elements.ColumnElement:
|
| foreign_keys = frozenset()
|
| key = None
|
| primary_key = False
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.roles.AllowsLambdaRole:
|
| allows_lambda = True
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.roles.UsesInspection:
|
| uses_inspection = True
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __class_getitem__(...)
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__(...)
| Function to initialize subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.operators.ColumnOperators:
|
| __add__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``+`` operator.
|
| In a column context, produces the clause ``a + b``
| if the parent object has non-string affinity.
| If the parent object has a string affinity,
| produces the concatenation operator, ``a || b`` -
| see :meth:`.ColumnOperators.concat`.
|
| __contains__(self, other: 'Any') -> 'ColumnOperators'
|
| __eq__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``==`` operator.
|
| In a column context, produces the clause ``a = b``.
| If the target is ``None``, produces ``a IS NULL``.
|
| __floordiv__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``//`` operator.
|
| In a column context, produces the clause ``a / b``,
| which is the same as "truediv", but considers the result
| type to be integer.
|
| .. versionadded:: 2.0
|
| __ge__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``>=`` operator.
|
| In a column context, produces the clause ``a >= b``.
|
| __getitem__(self, index: 'Any') -> 'ColumnOperators'
| Implement the [] operator.
|
| This can be used by some database-specific types
| such as PostgreSQL ARRAY and HSTORE.
|
| __gt__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``>`` operator.
|
| In a column context, produces the clause ``a > b``.
|
| __hash__(self, /) from builtins.object
| Return hash(self).
|
| __le__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``<=`` operator.
|
| In a column context, produces the clause ``a <= b``.
|
| __lshift__(self, other: 'Any') -> 'ColumnOperators'
| implement the << operator.
|
| Not used by SQLAlchemy core, this is provided
| for custom operator systems which want to use
| << as an extension point.
|
| __lt__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``<`` operator.
|
| In a column context, produces the clause ``a < b``.
|
| __mod__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``%`` operator.
|
| In a column context, produces the clause ``a % b``.
|
| __mul__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``*`` operator.
|
| In a column context, produces the clause ``a * b``.
|
| __ne__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``!=`` operator.
|
| In a column context, produces the clause ``a != b``.
| If the target is ``None``, produces ``a IS NOT NULL``.
|
| __neg__(self) -> 'ColumnOperators'
| Implement the ``-`` operator.
|
| In a column context, produces the clause ``-a``.
|
| __radd__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``+`` operator in reverse.
|
| See :meth:`.ColumnOperators.__add__`.
|
| __rfloordiv__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``//`` operator in reverse.
|
| See :meth:`.ColumnOperators.__floordiv__`.
|
| __rmod__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``%`` operator in reverse.
|
| See :meth:`.ColumnOperators.__mod__`.
|
| __rmul__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``*`` operator in reverse.
|
| See :meth:`.ColumnOperators.__mul__`.
|
| __rshift__(self, other: 'Any') -> 'ColumnOperators'
| implement the >> operator.
|
| Not used by SQLAlchemy core, this is provided
| for custom operator systems which want to use
| >> as an extension point.
|
| __rsub__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``-`` operator in reverse.
|
| See :meth:`.ColumnOperators.__sub__`.
|
| __rtruediv__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``/`` operator in reverse.
|
| See :meth:`.ColumnOperators.__truediv__`.
|
| __sub__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``-`` operator.
|
| In a column context, produces the clause ``a - b``.
|
| __truediv__(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``/`` operator.
|
| In a column context, produces the clause ``a / b``, and
| considers the result type to be numeric.
|
| .. versionchanged:: 2.0 The truediv operator against two integers
| is now considered to return a numeric value. Behavior on specific
| backends may vary.
|
| all_(self) -> 'ColumnOperators'
| Produce an :func:`_expression.all_` clause against the
| parent object.
|
| See the documentation for :func:`_sql.all_` for examples.
|
| .. note:: be sure to not confuse the newer
| :meth:`_sql.ColumnOperators.all_` method with the **legacy**
| version of this method, the :meth:`_types.ARRAY.Comparator.all`
| method that's specific to :class:`_types.ARRAY`, which uses a
| different calling style.
|
| any_(self) -> 'ColumnOperators'
| Produce an :func:`_expression.any_` clause against the
| parent object.
|
| See the documentation for :func:`_sql.any_` for examples.
|
| .. note:: be sure to not confuse the newer
| :meth:`_sql.ColumnOperators.any_` method with the **legacy**
| version of this method, the :meth:`_types.ARRAY.Comparator.any`
| method that's specific to :class:`_types.ARRAY`, which uses a
| different calling style.
|
| asc(self) -> 'ColumnOperators'
| Produce a :func:`_expression.asc` clause against the
| parent object.
|
| between(self, cleft: 'Any', cright: 'Any', symmetric: 'bool' = False) -> 'ColumnOperators'
| Produce a :func:`_expression.between` clause against
| the parent object, given the lower and upper range.
|
| bitwise_and(self, other: 'Any') -> 'ColumnOperators'
| Produce a bitwise AND operation, typically via the ``&``
| operator.
|
| .. versionadded:: 2.0.2
|
| .. seealso::
|
| :ref:`operators_bitwise`
|
| bitwise_lshift(self, other: 'Any') -> 'ColumnOperators'
| Produce a bitwise LSHIFT operation, typically via the ``<<``
| operator.
|
| .. versionadded:: 2.0.2
|
| .. seealso::
|
| :ref:`operators_bitwise`
|
| bitwise_not(self) -> 'ColumnOperators'
| Produce a bitwise NOT operation, typically via the ``~``
| operator.
|
| .. versionadded:: 2.0.2
|
| .. seealso::
|
| :ref:`operators_bitwise`
|
| bitwise_or(self, other: 'Any') -> 'ColumnOperators'
| Produce a bitwise OR operation, typically via the ``|``
| operator.
|
| .. versionadded:: 2.0.2
|
| .. seealso::
|
| :ref:`operators_bitwise`
|
| bitwise_rshift(self, other: 'Any') -> 'ColumnOperators'
| Produce a bitwise RSHIFT operation, typically via the ``>>``
| operator.
|
| .. versionadded:: 2.0.2
|
| .. seealso::
|
| :ref:`operators_bitwise`
|
| bitwise_xor(self, other: 'Any') -> 'ColumnOperators'
| Produce a bitwise XOR operation, typically via the ``^``
| operator, or ``#`` for PostgreSQL.
|
| .. versionadded:: 2.0.2
|
| .. seealso::
|
| :ref:`operators_bitwise`
|
| collate(self, collation: 'str') -> 'ColumnOperators'
| Produce a :func:`_expression.collate` clause against
| the parent object, given the collation string.
|
| .. seealso::
|
| :func:`_expression.collate`
|
| concat(self, other: 'Any') -> 'ColumnOperators'
| Implement the 'concat' operator.
|
| In a column context, produces the clause ``a || b``,
| or uses the ``concat()`` operator on MySQL.
|
| contains(self, other: 'Any', **kw: 'Any') -> 'ColumnOperators'
| Implement the 'contains' operator.
|
| Produces a LIKE expression that tests against a match for the middle
| of a string value:
|
| .. sourcecode:: sql
|
| column LIKE '%' || <other> || '%'
|
| E.g.::
|
| stmt = select(sometable).where(sometable.c.column.contains("foobar"))
|
| Since the operator uses ``LIKE``, wildcard characters
| ``"%"`` and ``"_"`` that are present inside the <other> expression
| will behave like wildcards as well. For literal string
| values, the :paramref:`.ColumnOperators.contains.autoescape` flag
| may be set to ``True`` to apply escaping to occurrences of these
| characters within the string value so that they match as themselves
| and not as wildcard characters. Alternatively, the
| :paramref:`.ColumnOperators.contains.escape` parameter will establish
| a given character as an escape character which can be of use when
| the target expression is not a literal string.
|
| :param other: expression to be compared. This is usually a plain
| string value, but can also be an arbitrary SQL expression. LIKE
| wildcard characters ``%`` and ``_`` are not escaped by default unless
| the :paramref:`.ColumnOperators.contains.autoescape` flag is
| set to True.
|
| :param autoescape: boolean; when True, establishes an escape character
| within the LIKE expression, then applies it to all occurrences of
| ``"%"``, ``"_"`` and the escape character itself within the
| comparison value, which is assumed to be a literal string and not a
| SQL expression.
|
| An expression such as::
|
| somecolumn.contains("foo%bar", autoescape=True)
|
| Will render as:
|
| .. sourcecode:: sql
|
| somecolumn LIKE '%' || :param || '%' ESCAPE '/'
|
| With the value of ``:param`` as ``"foo/%bar"``.
|
| :param escape: a character which when given will render with the
| ``ESCAPE`` keyword to establish that character as the escape
| character. This character can then be placed preceding occurrences
| of ``%`` and ``_`` to allow them to act as themselves and not
| wildcard characters.
|
| An expression such as::
|
| somecolumn.contains("foo/%bar", escape="^")
|
| Will render as:
|
| .. sourcecode:: sql
|
| somecolumn LIKE '%' || :param || '%' ESCAPE '^'
|
| The parameter may also be combined with
| :paramref:`.ColumnOperators.contains.autoescape`::
|
| somecolumn.contains("foo%bar^bat", escape="^", autoescape=True)
|
| Where above, the given literal parameter will be converted to
| ``"foo^%bar^^bat"`` before being passed to the database.
|
| .. seealso::
|
| :meth:`.ColumnOperators.startswith`
|
| :meth:`.ColumnOperators.endswith`
|
| :meth:`.ColumnOperators.like`
|
| desc(self) -> 'ColumnOperators'
| Produce a :func:`_expression.desc` clause against the
| parent object.
|
| distinct(self) -> 'ColumnOperators'
| Produce a :func:`_expression.distinct` clause against the
| parent object.
|
| endswith(self, other: 'Any', escape: 'Optional[str]' = None, autoescape: 'bool' = False) -> 'ColumnOperators'
| Implement the 'endswith' operator.
|
| Produces a LIKE expression that tests against a match for the end
| of a string value:
|
| .. sourcecode:: sql
|
| column LIKE '%' || <other>
|
| E.g.::
|
| stmt = select(sometable).where(sometable.c.column.endswith("foobar"))
|
| Since the operator uses ``LIKE``, wildcard characters
| ``"%"`` and ``"_"`` that are present inside the <other> expression
| will behave like wildcards as well. For literal string
| values, the :paramref:`.ColumnOperators.endswith.autoescape` flag
| may be set to ``True`` to apply escaping to occurrences of these
| characters within the string value so that they match as themselves
| and not as wildcard characters. Alternatively, the
| :paramref:`.ColumnOperators.endswith.escape` parameter will establish
| a given character as an escape character which can be of use when
| the target expression is not a literal string.
|
| :param other: expression to be compared. This is usually a plain
| string value, but can also be an arbitrary SQL expression. LIKE
| wildcard characters ``%`` and ``_`` are not escaped by default unless
| the :paramref:`.ColumnOperators.endswith.autoescape` flag is
| set to True.
|
| :param autoescape: boolean; when True, establishes an escape character
| within the LIKE expression, then applies it to all occurrences of
| ``"%"``, ``"_"`` and the escape character itself within the
| comparison value, which is assumed to be a literal string and not a
| SQL expression.
|
| An expression such as::
|
| somecolumn.endswith("foo%bar", autoescape=True)
|
| Will render as:
|
| .. sourcecode:: sql
|
| somecolumn LIKE '%' || :param ESCAPE '/'
|
| With the value of ``:param`` as ``"foo/%bar"``.
|
| :param escape: a character which when given will render with the
| ``ESCAPE`` keyword to establish that character as the escape
| character. This character can then be placed preceding occurrences
| of ``%`` and ``_`` to allow them to act as themselves and not
| wildcard characters.
|
| An expression such as::
|
| somecolumn.endswith("foo/%bar", escape="^")
|
| Will render as:
|
| .. sourcecode:: sql
|
| somecolumn LIKE '%' || :param ESCAPE '^'
|
| The parameter may also be combined with
| :paramref:`.ColumnOperators.endswith.autoescape`::
|
| somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
|
| Where above, the given literal parameter will be converted to
| ``"foo^%bar^^bat"`` before being passed to the database.
|
| .. seealso::
|
| :meth:`.ColumnOperators.startswith`
|
| :meth:`.ColumnOperators.contains`
|
| :meth:`.ColumnOperators.like`
|
| icontains(self, other: 'Any', **kw: 'Any') -> 'ColumnOperators'
| Implement the ``icontains`` operator, e.g. case insensitive
| version of :meth:`.ColumnOperators.contains`.
|
| Produces a LIKE expression that tests against an insensitive match
| for the middle of a string value:
|
| .. sourcecode:: sql
|
| lower(column) LIKE '%' || lower(<other>) || '%'
|
| E.g.::
|
| stmt = select(sometable).where(sometable.c.column.icontains("foobar"))
|
| Since the operator uses ``LIKE``, wildcard characters
| ``"%"`` and ``"_"`` that are present inside the <other> expression
| will behave like wildcards as well. For literal string
| values, the :paramref:`.ColumnOperators.icontains.autoescape` flag
| may be set to ``True`` to apply escaping to occurrences of these
| characters within the string value so that they match as themselves
| and not as wildcard characters. Alternatively, the
| :paramref:`.ColumnOperators.icontains.escape` parameter will establish
| a given character as an escape character which can be of use when
| the target expression is not a literal string.
|
| :param other: expression to be compared. This is usually a plain
| string value, but can also be an arbitrary SQL expression. LIKE
| wildcard characters ``%`` and ``_`` are not escaped by default unless
| the :paramref:`.ColumnOperators.icontains.autoescape` flag is
| set to True.
|
| :param autoescape: boolean; when True, establishes an escape character
| within the LIKE expression, then applies it to all occurrences of
| ``"%"``, ``"_"`` and the escape character itself within the
| comparison value, which is assumed to be a literal string and not a
| SQL expression.
|
| An expression such as::
|
| somecolumn.icontains("foo%bar", autoescape=True)
|
| Will render as:
|
| .. sourcecode:: sql
|
| lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'
|
| With the value of ``:param`` as ``"foo/%bar"``.
|
| :param escape: a character which when given will render with the
| ``ESCAPE`` keyword to establish that character as the escape
| character. This character can then be placed preceding occurrences
| of ``%`` and ``_`` to allow them to act as themselves and not
| wildcard characters.
|
| An expression such as::
|
| somecolumn.icontains("foo/%bar", escape="^")
|
| Will render as:
|
| .. sourcecode:: sql
|
| lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'
|
| The parameter may also be combined with
| :paramref:`.ColumnOperators.contains.autoescape`::
|
| somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)
|
| Where above, the given literal parameter will be converted to
| ``"foo^%bar^^bat"`` before being passed to the database.
|
| .. seealso::
|
| :meth:`.ColumnOperators.contains`
|
| iendswith(self, other: 'Any', escape: 'Optional[str]' = None, autoescape: 'bool' = False) -> 'ColumnOperators'
| Implement the ``iendswith`` operator, e.g. case insensitive
| version of :meth:`.ColumnOperators.endswith`.
|
| Produces a LIKE expression that tests against an insensitive match
| for the end of a string value:
|
| .. sourcecode:: sql
|
| lower(column) LIKE '%' || lower(<other>)
|
| E.g.::
|
| stmt = select(sometable).where(sometable.c.column.iendswith("foobar"))
|
| Since the operator uses ``LIKE``, wildcard characters
| ``"%"`` and ``"_"`` that are present inside the <other> expression
| will behave like wildcards as well. For literal string
| values, the :paramref:`.ColumnOperators.iendswith.autoescape` flag
| may be set to ``True`` to apply escaping to occurrences of these
| characters within the string value so that they match as themselves
| and not as wildcard characters. Alternatively, the
| :paramref:`.ColumnOperators.iendswith.escape` parameter will establish
| a given character as an escape character which can be of use when
| the target expression is not a literal string.
|
| :param other: expression to be compared. This is usually a plain
| string value, but can also be an arbitrary SQL expression. LIKE
| wildcard characters ``%`` and ``_`` are not escaped by default unless
| the :paramref:`.ColumnOperators.iendswith.autoescape` flag is
| set to True.
|
| :param autoescape: boolean; when True, establishes an escape character
| within the LIKE expression, then applies it to all occurrences of
| ``"%"``, ``"_"`` and the escape character itself within the
| comparison value, which is assumed to be a literal string and not a
| SQL expression.
|
| An expression such as::
|
| somecolumn.iendswith("foo%bar", autoescape=True)
|
| Will render as:
|
| .. sourcecode:: sql
|
| lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'
|
| With the value of ``:param`` as ``"foo/%bar"``.
|
| :param escape: a character which when given will render with the
| ``ESCAPE`` keyword to establish that character as the escape
| character. This character can then be placed preceding occurrences
| of ``%`` and ``_`` to allow them to act as themselves and not
| wildcard characters.
|
| An expression such as::
|
| somecolumn.iendswith("foo/%bar", escape="^")
|
| Will render as:
|
| .. sourcecode:: sql
|
| lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'
|
| The parameter may also be combined with
| :paramref:`.ColumnOperators.iendswith.autoescape`::
|
| somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
|
| Where above, the given literal parameter will be converted to
| ``"foo^%bar^^bat"`` before being passed to the database.
|
| .. seealso::
|
| :meth:`.ColumnOperators.endswith`
|
| ilike(self, other: 'Any', escape: 'Optional[str]' = None) -> 'ColumnOperators'
| Implement the ``ilike`` operator, e.g. case insensitive LIKE.
|
| In a column context, produces an expression either of the form:
|
| .. sourcecode:: sql
|
| lower(a) LIKE lower(other)
|
| Or on backends that support the ILIKE operator:
|
| .. sourcecode:: sql
|
| a ILIKE other
|
| E.g.::
|
| stmt = select(sometable).where(sometable.c.column.ilike("%foobar%"))
|
| :param other: expression to be compared
| :param escape: optional escape character, renders the ``ESCAPE``
| keyword, e.g.::
|
| somecolumn.ilike("foo/%bar", escape="/")
|
| .. seealso::
|
| :meth:`.ColumnOperators.like`
|
| in_(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``in`` operator.
|
| In a column context, produces the clause ``column IN <other>``.
|
| The given parameter ``other`` may be:
|
| * A list of literal values,
| e.g.::
|
| stmt.where(column.in_([1, 2, 3]))
|
| In this calling form, the list of items is converted to a set of
| bound parameters the same length as the list given:
|
| .. sourcecode:: sql
|
| WHERE COL IN (?, ?, ?)
|
| * A list of tuples may be provided if the comparison is against a
| :func:`.tuple_` containing multiple expressions::
|
| from sqlalchemy import tuple_
|
| stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))
|
| * An empty list,
| e.g.::
|
| stmt.where(column.in_([]))
|
| In this calling form, the expression renders an "empty set"
| expression. These expressions are tailored to individual backends
| and are generally trying to get an empty SELECT statement as a
| subquery. Such as on SQLite, the expression is:
|
| .. sourcecode:: sql
|
| WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
|
| .. versionchanged:: 1.4 empty IN expressions now use an
| execution-time generated SELECT subquery in all cases.
|
| * A bound parameter, e.g. :func:`.bindparam`, may be used if it
| includes the :paramref:`.bindparam.expanding` flag::
|
| stmt.where(column.in_(bindparam("value", expanding=True)))
|
| In this calling form, the expression renders a special non-SQL
| placeholder expression that looks like:
|
| .. sourcecode:: sql
|
| WHERE COL IN ([EXPANDING_value])
|
| This placeholder expression is intercepted at statement execution
| time to be converted into the variable number of bound parameter
| form illustrated earlier. If the statement were executed as::
|
| connection.execute(stmt, {"value": [1, 2, 3]})
|
| The database would be passed a bound parameter for each value:
|
| .. sourcecode:: sql
|
| WHERE COL IN (?, ?, ?)
|
| .. versionadded:: 1.2 added "expanding" bound parameters
|
| If an empty list is passed, a special "empty list" expression,
| which is specific to the database in use, is rendered. On
| SQLite this would be:
|
| .. sourcecode:: sql
|
| WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
|
| .. versionadded:: 1.3 "expanding" bound parameters now support
| empty lists
|
| * a :func:`_expression.select` construct, which is usually a
| correlated scalar select::
|
| stmt.where(
| column.in_(select(othertable.c.y).where(table.c.x == othertable.c.x))
| )
|
| In this calling form, :meth:`.ColumnOperators.in_` renders as given:
|
| .. sourcecode:: sql
|
| WHERE COL IN (SELECT othertable.y
| FROM othertable WHERE othertable.x = table.x)
|
| :param other: a list of literals, a :func:`_expression.select`
| construct, or a :func:`.bindparam` construct that includes the
| :paramref:`.bindparam.expanding` flag set to True.
|
| is_(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``IS`` operator.
|
| Normally, ``IS`` is generated automatically when comparing to a
| value of ``None``, which resolves to ``NULL``. However, explicit
| usage of ``IS`` may be desirable if comparing to boolean values
| on certain platforms.
|
| .. seealso:: :meth:`.ColumnOperators.is_not`
|
| is_distinct_from(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``IS DISTINCT FROM`` operator.
|
| Renders "a IS DISTINCT FROM b" on most platforms;
| on some such as SQLite may render "a IS NOT b".
|
| is_not(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``IS NOT`` operator.
|
| Normally, ``IS NOT`` is generated automatically when comparing to a
| value of ``None``, which resolves to ``NULL``. However, explicit
| usage of ``IS NOT`` may be desirable if comparing to boolean values
| on certain platforms.
|
| .. versionchanged:: 1.4 The ``is_not()`` operator is renamed from
| ``isnot()`` in previous releases. The previous name remains
| available for backwards compatibility.
|
| .. seealso:: :meth:`.ColumnOperators.is_`
|
| is_not_distinct_from(self, other: 'Any') -> 'ColumnOperators'
| Implement the ``IS NOT DISTINCT FROM`` operator.
|
| Renders "a IS NOT DISTINCT FROM b" on most platforms;
| on some such as SQLite may render "a IS b".
|
| .. versionchanged:: 1.4 The ``is_not_distinct_from()`` operator is
| renamed from ``isnot_distinct_from()`` in previous releases.
| The previous name remains available for backwards compatibility.
|
| isnot = is_not(self, other: 'Any') -> 'ColumnOperators'
|
| isnot_distinct_from = is_not_distinct_from(self, other: 'Any') -> 'ColumnOperators'
|
| istartswith(self, other: 'Any', escape: 'Optional[str]' = None, autoescape: 'bool' = False) -> 'ColumnOperators'
| Implement the ``istartswith`` operator, e.g. case insensitive
| version of :meth:`.ColumnOperators.startswith`.
|
| Produces a LIKE expression that tests against an insensitive
| match for the start of a string value:
|
| .. sourcecode:: sql
|
| lower(column) LIKE lower(<other>) || '%'
|
| E.g.::
|
| stmt = select(sometable).where(sometable.c.column.istartswith("foobar"))
|
| Since the operator uses ``LIKE``, wildcard characters
| ``"%"`` and ``"_"`` that are present inside the <other> expression
| will behave like wildcards as well. For literal string
| values, the :paramref:`.ColumnOperators.istartswith.autoescape` flag
| may be set to ``True`` to apply escaping to occurrences of these
| characters within the string value so that they match as themselves
| and not as wildcard characters. Alternatively, the
| :paramref:`.ColumnOperators.istartswith.escape` parameter will
| establish a given character as an escape character which can be of
| use when the target expression is not a literal string.
|
| :param other: expression to be compared. This is usually a plain
| string value, but can also be an arbitrary SQL expression. LIKE
| wildcard characters ``%`` and ``_`` are not escaped by default unless
| the :paramref:`.ColumnOperators.istartswith.autoescape` flag is
| set to True.
|
| :param autoescape: boolean; when True, establishes an escape character
| within the LIKE expression, then applies it to all occurrences of
| ``"%"``, ``"_"`` and the escape character itself within the
| comparison value, which is assumed to be a literal string and not a
| SQL expression.
|
| An expression such as::
|
| somecolumn.istartswith("foo%bar", autoescape=True)
|
| Will render as:
|
| .. sourcecode:: sql
|
| lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'
|
| With the value of ``:param`` as ``"foo/%bar"``.
|
| :param escape: a character which when given will render with the
| ``ESCAPE`` keyword to establish that character as the escape
| character. This character can then be placed preceding occurrences
| of ``%`` and ``_`` to allow them to act as themselves and not
| wildcard characters.
|
| An expression such as::
|
| somecolumn.istartswith("foo/%bar", escape="^")
|
| Will render as:
|
| .. sourcecode:: sql
|
| lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'
|
| The parameter may also be combined with
| :paramref:`.ColumnOperators.istartswith.autoescape`::
|
| somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)
|
| Where above, the given literal parameter will be converted to
| ``"foo^%bar^^bat"`` before being passed to the database.
|
| .. seealso::
|
| :meth:`.ColumnOperators.startswith`
|
| like(self, other: 'Any', escape: 'Optional[str]' = None) -> 'ColumnOperators'
| Implement the ``like`` operator.
|
| In a column context, produces the expression:
|
| .. sourcecode:: sql
|
| a LIKE other
|
| E.g.::
|
| stmt = select(sometable).where(sometable.c.column.like("%foobar%"))
|
| :param other: expression to be compared
| :param escape: optional escape character, renders the ``ESCAPE``
| keyword, e.g.::
|
| somecolumn.like("foo/%bar", escape="/")
|
| .. seealso::
|
| :meth:`.ColumnOperators.ilike`
|
| match(self, other: 'Any', **kwargs: 'Any') -> 'ColumnOperators'
| Implements a database-specific 'match' operator.
|
| :meth:`_sql.ColumnOperators.match` attempts to resolve to
| a MATCH-like function or operator provided by the backend.
| Examples include:
|
| * PostgreSQL - renders ``x @@ plainto_tsquery(y)``
|
| .. versionchanged:: 2.0 ``plainto_tsquery()`` is used instead
| of ``to_tsquery()`` for PostgreSQL now; for compatibility with
| other forms, see :ref:`postgresql_match`.
|
|
| * MySQL - renders ``MATCH (x) AGAINST (y IN BOOLEAN MODE)``
|
| .. seealso::
|
| :class:`_mysql.match` - MySQL specific construct with
| additional features.
|
| * Oracle Database - renders ``CONTAINS(x, y)``
| * other backends may provide special implementations.
| * Backends without any special implementation will emit
| the operator as "MATCH". This is compatible with SQLite, for
| example.
|
| not_ilike(self, other: 'Any', escape: 'Optional[str]' = None) -> 'ColumnOperators'
| implement the ``NOT ILIKE`` operator.
|
| This is equivalent to using negation with
| :meth:`.ColumnOperators.ilike`, i.e. ``~x.ilike(y)``.
|
| .. versionchanged:: 1.4 The ``not_ilike()`` operator is renamed from
| ``notilike()`` in previous releases. The previous name remains
| available for backwards compatibility.
|
| .. seealso::
|
| :meth:`.ColumnOperators.ilike`
|
| not_in(self, other: 'Any') -> 'ColumnOperators'
| implement the ``NOT IN`` operator.
|
| This is equivalent to using negation with
| :meth:`.ColumnOperators.in_`, i.e. ``~x.in_(y)``.
|
| In the case that ``other`` is an empty sequence, the compiler
| produces an "empty not in" expression. This defaults to the
| expression "1 = 1" to produce true in all cases. The
| :paramref:`_sa.create_engine.empty_in_strategy` may be used to
| alter this behavior.
|
| .. versionchanged:: 1.4 The ``not_in()`` operator is renamed from
| ``notin_()`` in previous releases. The previous name remains
| available for backwards compatibility.
|
| .. versionchanged:: 1.2 The :meth:`.ColumnOperators.in_` and
| :meth:`.ColumnOperators.not_in` operators
| now produce a "static" expression for an empty IN sequence
| by default.
|
| .. seealso::
|
| :meth:`.ColumnOperators.in_`
|
| not_like(self, other: 'Any', escape: 'Optional[str]' = None) -> 'ColumnOperators'
| implement the ``NOT LIKE`` operator.
|
| This is equivalent to using negation with
| :meth:`.ColumnOperators.like`, i.e. ``~x.like(y)``.
|
| .. versionchanged:: 1.4 The ``not_like()`` operator is renamed from
| ``notlike()`` in previous releases. The previous name remains
| available for backwards compatibility.
|
| .. seealso::
|
| :meth:`.ColumnOperators.like`
|
| notilike = not_ilike(self, other: 'Any', escape: 'Optional[str]' = None) -> 'ColumnOperators'
|
| notin_ = not_in(self, other: 'Any') -> 'ColumnOperators'
|
| notlike = not_like(self, other: 'Any', escape: 'Optional[str]' = None) -> 'ColumnOperators'
|
| nulls_first(self) -> 'ColumnOperators'
| Produce a :func:`_expression.nulls_first` clause against the
| parent object.
|
| .. versionchanged:: 1.4 The ``nulls_first()`` operator is
| renamed from ``nullsfirst()`` in previous releases.
| The previous name remains available for backwards compatibility.
|
| nulls_last(self) -> 'ColumnOperators'
| Produce a :func:`_expression.nulls_last` clause against the
| parent object.
|
| .. versionchanged:: 1.4 The ``nulls_last()`` operator is
| renamed from ``nullslast()`` in previous releases.
| The previous name remains available for backwards compatibility.
|
| nullsfirst = nulls_first(self) -> 'ColumnOperators'
|
| nullslast = nulls_last(self) -> 'ColumnOperators'
|
| regexp_match(self, pattern: 'Any', flags: 'Optional[str]' = None) -> 'ColumnOperators'
| Implements a database-specific 'regexp match' operator.
|
| E.g.::
|
| stmt = select(table.c.some_column).where(
| table.c.some_column.regexp_match("^(b|c)")
| )
|
| :meth:`_sql.ColumnOperators.regexp_match` attempts to resolve to
| a REGEXP-like function or operator provided by the backend, however
| the specific regular expression syntax and flags available are
| **not backend agnostic**.
|
| Examples include:
|
| * PostgreSQL - renders ``x ~ y`` or ``x !~ y`` when negated.
| * Oracle Database - renders ``REGEXP_LIKE(x, y)``
| * SQLite - uses SQLite's ``REGEXP`` placeholder operator and calls into
| the Python ``re.match()`` builtin.
| * other backends may provide special implementations.
| * Backends without any special implementation will emit
| the operator as "REGEXP" or "NOT REGEXP". This is compatible with
| SQLite and MySQL, for example.
|
| Regular expression support is currently implemented for Oracle
| Database, PostgreSQL, MySQL and MariaDB. Partial support is available
| for SQLite. Support among third-party dialects may vary.
|
| :param pattern: The regular expression pattern string or column
| clause.
| :param flags: Any regular expression string flags to apply, passed as
| plain Python string only. These flags are backend specific.
| Some backends, like PostgreSQL and MariaDB, may alternatively
| specify the flags as part of the pattern.
| When using the ignore case flag 'i' in PostgreSQL, the ignore case
| regexp match operator ``~*`` or ``!~*`` will be used.
|
| .. versionadded:: 1.4
|
| .. versionchanged:: 1.4.48, 2.0.18 Note that due to an implementation
| error, the "flags" parameter previously accepted SQL expression
| objects such as column expressions in addition to plain Python
| strings. This implementation did not work correctly with caching
| and was removed; strings only should be passed for the "flags"
| parameter, as these flags are rendered as literal inline values
| within SQL expressions.
|
| .. seealso::
|
| :meth:`_sql.ColumnOperators.regexp_replace`
|
| regexp_replace(self, pattern: 'Any', replacement: 'Any', flags: 'Optional[str]' = None) -> 'ColumnOperators'
| Implements a database-specific 'regexp replace' operator.
|
| E.g.::
|
| stmt = select(
| table.c.some_column.regexp_replace("b(..)", "XY", flags="g")
| )
|
| :meth:`_sql.ColumnOperators.regexp_replace` attempts to resolve to
| a REGEXP_REPLACE-like function provided by the backend, that
| usually emit the function ``REGEXP_REPLACE()``. However,
| the specific regular expression syntax and flags available are
| **not backend agnostic**.
|
| Regular expression replacement support is currently implemented for
| Oracle Database, PostgreSQL, MySQL 8 or greater and MariaDB. Support
| among third-party dialects may vary.
|
| :param pattern: The regular expression pattern string or column
| clause.
| :param pattern: The replacement string or column clause.
| :param flags: Any regular expression string flags to apply, passed as
| plain Python string only. These flags are backend specific.
| Some backends, like PostgreSQL and MariaDB, may alternatively
| specify the flags as part of the pattern.
|
| .. versionadded:: 1.4
|
| .. versionchanged:: 1.4.48, 2.0.18 Note that due to an implementation
| error, the "flags" parameter previously accepted SQL expression
| objects such as column expressions in addition to plain Python
| strings. This implementation did not work correctly with caching
| and was removed; strings only should be passed for the "flags"
| parameter, as these flags are rendered as literal inline values
| within SQL expressions.
|
|
| .. seealso::
|
| :meth:`_sql.ColumnOperators.regexp_match`
|
| startswith(self, other: 'Any', escape: 'Optional[str]' = None, autoescape: 'bool' = False) -> 'ColumnOperators'
| Implement the ``startswith`` operator.
|
| Produces a LIKE expression that tests against a match for the start
| of a string value:
|
| .. sourcecode:: sql
|
| column LIKE <other> || '%'
|
| E.g.::
|
| stmt = select(sometable).where(sometable.c.column.startswith("foobar"))
|
| Since the operator uses ``LIKE``, wildcard characters
| ``"%"`` and ``"_"`` that are present inside the <other> expression
| will behave like wildcards as well. For literal string
| values, the :paramref:`.ColumnOperators.startswith.autoescape` flag
| may be set to ``True`` to apply escaping to occurrences of these
| characters within the string value so that they match as themselves
| and not as wildcard characters. Alternatively, the
| :paramref:`.ColumnOperators.startswith.escape` parameter will establish
| a given character as an escape character which can be of use when
| the target expression is not a literal string.
|
| :param other: expression to be compared. This is usually a plain
| string value, but can also be an arbitrary SQL expression. LIKE
| wildcard characters ``%`` and ``_`` are not escaped by default unless
| the :paramref:`.ColumnOperators.startswith.autoescape` flag is
| set to True.
|
| :param autoescape: boolean; when True, establishes an escape character
| within the LIKE expression, then applies it to all occurrences of
| ``"%"``, ``"_"`` and the escape character itself within the
| comparison value, which is assumed to be a literal string and not a
| SQL expression.
|
| An expression such as::
|
| somecolumn.startswith("foo%bar", autoescape=True)
|
| Will render as:
|
| .. sourcecode:: sql
|
| somecolumn LIKE :param || '%' ESCAPE '/'
|
| With the value of ``:param`` as ``"foo/%bar"``.
|
| :param escape: a character which when given will render with the
| ``ESCAPE`` keyword to establish that character as the escape
| character. This character can then be placed preceding occurrences
| of ``%`` and ``_`` to allow them to act as themselves and not
| wildcard characters.
|
| An expression such as::
|
| somecolumn.startswith("foo/%bar", escape="^")
|
| Will render as:
|
| .. sourcecode:: sql
|
| somecolumn LIKE :param || '%' ESCAPE '^'
|
| The parameter may also be combined with
| :paramref:`.ColumnOperators.startswith.autoescape`::
|
| somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True)
|
| Where above, the given literal parameter will be converted to
| ``"foo^%bar^^bat"`` before being passed to the database.
|
| .. seealso::
|
| :meth:`.ColumnOperators.endswith`
|
| :meth:`.ColumnOperators.contains`
|
| :meth:`.ColumnOperators.like`
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.operators.ColumnOperators:
|
| timetuple = None
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.operators.Operators:
|
| __and__(self, other: 'Any') -> 'Operators'
| Implement the ``&`` operator.
|
| When used with SQL expressions, results in an
| AND operation, equivalent to
| :func:`_expression.and_`, that is::
|
| a & b
|
| is equivalent to::
|
| from sqlalchemy import and_
|
| and_(a, b)
|
| Care should be taken when using ``&`` regarding
| operator precedence; the ``&`` operator has the highest precedence.
| The operands should be enclosed in parenthesis if they contain
| further sub expressions::
|
| (a == 2) & (b == 4)
|
| __invert__(self) -> 'Operators'
| Implement the ``~`` operator.
|
| When used with SQL expressions, results in a
| NOT operation, equivalent to
| :func:`_expression.not_`, that is::
|
| ~a
|
| is equivalent to::
|
| from sqlalchemy import not_
|
| not_(a)
|
| __or__(self, other: 'Any') -> 'Operators'
| Implement the ``|`` operator.
|
| When used with SQL expressions, results in an
| OR operation, equivalent to
| :func:`_expression.or_`, that is::
|
| a | b
|
| is equivalent to::
|
| from sqlalchemy import or_
|
| or_(a, b)
|
| Care should be taken when using ``|`` regarding
| operator precedence; the ``|`` operator has the highest precedence.
| The operands should be enclosed in parenthesis if they contain
| further sub expressions::
|
| (a == 2) | (b == 4)
|
| __sa_operate__ = operate(self, op: 'OperatorType', *other: 'Any', **kwargs: 'Any') -> 'Operators'
| Operate on an argument.
|
| This is the lowest level of operation, raises
| :class:`NotImplementedError` by default.
|
| Overriding this on a subclass can allow common
| behavior to be applied to all operations.
| For example, overriding :class:`.ColumnOperators`
| to apply ``func.lower()`` to the left and right
| side::
|
| class MyComparator(ColumnOperators):
| def operate(self, op, other, **kwargs):
| return op(func.lower(self), func.lower(other), **kwargs)
|
| :param op: Operator callable.
| :param \*other: the 'other' side of the operation. Will
| be a single scalar for most operations.
| :param \**kwargs: modifiers. These may be passed by special
| operators such as :meth:`ColumnOperators.contains`.
|
| bool_op(self, opstring: 'str', precedence: 'int' = 0, python_impl: 'Optional[Callable[..., Any]]' = None) -> 'Callable[[Any], Operators]'
| Return a custom boolean operator.
|
| This method is shorthand for calling
| :meth:`.Operators.op` and passing the
| :paramref:`.Operators.op.is_comparison`
| flag with True. A key advantage to using :meth:`.Operators.bool_op`
| is that when using column constructs, the "boolean" nature of the
| returned expression will be present for :pep:`484` purposes.
|
| .. seealso::
|
| :meth:`.Operators.op`
|
| op(self, opstring: 'str', precedence: 'int' = 0, is_comparison: 'bool' = False, return_type: 'Optional[Union[Type[TypeEngine[Any]], TypeEngine[Any]]]' = None, python_impl: 'Optional[Callable[..., Any]]' = None) -> 'Callable[[Any], Operators]'
| Produce a generic operator function.
|
| e.g.::
|
| somecolumn.op("*")(5)
|
| produces::
|
| somecolumn * 5
|
| This function can also be used to make bitwise operators explicit. For
| example::
|
| somecolumn.op("&")(0xFF)
|
| is a bitwise AND of the value in ``somecolumn``.
|
| :param opstring: a string which will be output as the infix operator
| between this element and the expression passed to the
| generated function.
|
| :param precedence: precedence which the database is expected to apply
| to the operator in SQL expressions. This integer value acts as a hint
| for the SQL compiler to know when explicit parenthesis should be
| rendered around a particular operation. A lower number will cause the
| expression to be parenthesized when applied against another operator
| with higher precedence. The default value of ``0`` is lower than all
| operators except for the comma (``,``) and ``AS`` operators. A value
| of 100 will be higher or equal to all operators, and -100 will be
| lower than or equal to all operators.
|
| .. seealso::
|
| :ref:`faq_sql_expression_op_parenthesis` - detailed description
| of how the SQLAlchemy SQL compiler renders parenthesis
|
| :param is_comparison: legacy; if True, the operator will be considered
| as a "comparison" operator, that is which evaluates to a boolean
| true/false value, like ``==``, ``>``, etc. This flag is provided
| so that ORM relationships can establish that the operator is a
| comparison operator when used in a custom join condition.
|
| Using the ``is_comparison`` parameter is superseded by using the
| :meth:`.Operators.bool_op` method instead; this more succinct
| operator sets this parameter automatically, but also provides
| correct :pep:`484` typing support as the returned object will
| express a "boolean" datatype, i.e. ``BinaryExpression[bool]``.
|
| :param return_type: a :class:`.TypeEngine` class or object that will
| force the return type of an expression produced by this operator
| to be of that type. By default, operators that specify
| :paramref:`.Operators.op.is_comparison` will resolve to
| :class:`.Boolean`, and those that do not will be of the same
| type as the left-hand operand.
|
| :param python_impl: an optional Python function that can evaluate
| two Python values in the same way as this operator works when
| run on the database server. Useful for in-Python SQL expression
| evaluation functions, such as for ORM hybrid attributes, and the
| ORM "evaluator" used to match objects in a session after a multi-row
| update or delete.
|
| e.g.::
|
| >>> expr = column("x").op("+", python_impl=lambda a, b: a + b)("y")
|
| The operator for the above expression will also work for non-SQL
| left and right objects::
|
| >>> expr.operator(5, 10)
| 15
|
| .. versionadded:: 2.0
|
|
| .. seealso::
|
| :meth:`.Operators.bool_op`
|
| :ref:`types_operators`
|
| :ref:`relationship_custom_operator`
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.elements.ClauseElement:
|
| __bool__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| compare(self, other: 'ClauseElement', **kw: 'Any') -> 'bool'
| Compare this :class:`_expression.ClauseElement` to
| the given :class:`_expression.ClauseElement`.
|
| Subclasses should override the default behavior, which is a
| straight identity comparison.
|
| \**kw are arguments consumed by subclass ``compare()`` methods and
| may be used to modify the criteria for comparison
| (see :class:`_expression.ColumnElement`).
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.elements.ClauseElement:
|
| is_clause_element = True
|
| is_dml = False
|
| is_selectable = False
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.util.langhelpers.HasMemoized:
|
| memoized_instancemethod(fn: '_F') -> '_F'
| Decorate a method memoize its return value.
|
| :meta private:
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.util.langhelpers.HasMemoized:
|
| memoized_attribute = <class 'sqlalchemy.util.langhelpers.HasMemoized.m...
| A read-only @property that is only evaluated once.
|
| :meta private:
|
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.elements.CompilerElement:
|
| compile(self, bind: 'Optional[_HasDialect]' = None, dialect: 'Optional[Dialect]' = None, **kw: 'Any') -> 'Compiled'
| Compile this SQL expression.
|
| The return value is a :class:`~.Compiled` object.
| Calling ``str()`` or ``unicode()`` on the returned value will yield a
| string representation of the result. The
| :class:`~.Compiled` object also can return a
| dictionary of bind parameter names and values
| using the ``params`` accessor.
|
| :param bind: An :class:`.Connection` or :class:`.Engine` which
| can provide a :class:`.Dialect` in order to generate a
| :class:`.Compiled` object. If the ``bind`` and
| ``dialect`` parameters are both omitted, a default SQL compiler
| is used.
|
| :param column_keys: Used for INSERT and UPDATE statements, a list of
| column names which should be present in the VALUES clause of the
| compiled statement. If ``None``, all columns from the target table
| object are rendered.
|
| :param dialect: A :class:`.Dialect` instance which can generate
| a :class:`.Compiled` object. This argument takes precedence over
| the ``bind`` argument.
|
| :param compile_kwargs: optional dictionary of additional parameters
| that will be passed through to the compiler within all "visit"
| methods. This allows any custom flag to be passed through to
| a custom compilation construct, for example. It is also used
| for the case of passing the ``literal_binds`` flag through::
|
| from sqlalchemy.sql import table, column, select
|
| t = table("t", column("x"))
|
| s = select(t).where(t.c.x == 5)
|
| print(s.compile(compile_kwargs={"literal_binds": True}))
|
| .. seealso::
|
| :ref:`faq_sql_expression_string`
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.elements.CompilerElement:
|
| stringify_dialect = 'default'
|
| supports_execution = False
sqlmodel.ColumnDefault
Python Library Documentation: class ColumnDefault in module sqlalchemy.sql.schema
class ColumnDefault(DefaultGenerator, abc.ABC)
| ColumnDefault(arg: 'Any' = None, for_update: 'bool' = False) -> 'ColumnDefault'
|
| A plain default value on a column.
|
| This could correspond to a constant, a callable function,
| or a SQL clause.
|
| :class:`.ColumnDefault` is generated automatically
| whenever the ``default``, ``onupdate`` arguments of
| :class:`_schema.Column` are used. A :class:`.ColumnDefault`
| can be passed positionally as well.
|
| For example, the following::
|
| Column("foo", Integer, default=50)
|
| Is equivalent to::
|
| Column("foo", Integer, ColumnDefault(50))
|
| Method resolution order:
| ColumnDefault
| DefaultGenerator
| sqlalchemy.sql.base.Executable
| sqlalchemy.sql.roles.StatementRole
| sqlalchemy.sql.roles.SQLRole
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, arg: 'Any' = None, for_update: 'bool' = False) -> 'ColumnDefault'
| Construct a new :class:`.ColumnDefault`.
|
|
| :param arg: argument representing the default value.
| May be one of the following:
|
| * a plain non-callable Python value, such as a
| string, integer, boolean, or other simple type.
| The default value will be used as is each time.
| * a SQL expression, that is one which derives from
| :class:`_expression.ColumnElement`. The SQL expression will
| be rendered into the INSERT or UPDATE statement,
| or in the case of a primary key column when
| RETURNING is not used may be
| pre-executed before an INSERT within a SELECT.
| * A Python callable. The function will be invoked for each
| new row subject to an INSERT or UPDATE.
| The callable must accept exactly
| zero or one positional arguments. The one-argument form
| will receive an instance of the :class:`.ExecutionContext`,
| which provides contextual information as to the current
| :class:`_engine.Connection` in use as well as the current
| statement and parameters.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'arg': 'Any'}
|
| ----------------------------------------------------------------------
| Methods inherited from DefaultGenerator:
|
| __init__(self, for_update: 'bool' = False) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from DefaultGenerator:
|
| __visit_name__ = 'default_generator'
|
| has_arg = False
|
| is_callable = False
|
| is_clause_element = False
|
| is_identity = False
|
| is_scalar = False
|
| is_sentinel = False
|
| is_sequence = False
|
| is_server_default = False
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.Executable:
|
| execution_options(self, **kw: 'Any') -> 'Self'
| Set non-SQL options for the statement which take effect during
| execution.
|
| Execution options can be set at many scopes, including per-statement,
| per-connection, or per execution, using methods such as
| :meth:`_engine.Connection.execution_options` and parameters which
| accept a dictionary of options such as
| :paramref:`_engine.Connection.execute.execution_options` and
| :paramref:`_orm.Session.execute.execution_options`.
|
| The primary characteristic of an execution option, as opposed to
| other kinds of options such as ORM loader options, is that
| **execution options never affect the compiled SQL of a query, only
| things that affect how the SQL statement itself is invoked or how
| results are fetched**. That is, execution options are not part of
| what's accommodated by SQL compilation nor are they considered part of
| the cached state of a statement.
|
| The :meth:`_sql.Executable.execution_options` method is
| :term:`generative`, as
| is the case for the method as applied to the :class:`_engine.Engine`
| and :class:`_orm.Query` objects, which means when the method is called,
| a copy of the object is returned, which applies the given parameters to
| that new copy, but leaves the original unchanged::
|
| statement = select(table.c.x, table.c.y)
| new_statement = statement.execution_options(my_option=True)
|
| An exception to this behavior is the :class:`_engine.Connection`
| object, where the :meth:`_engine.Connection.execution_options` method
| is explicitly **not** generative.
|
| The kinds of options that may be passed to
| :meth:`_sql.Executable.execution_options` and other related methods and
| parameter dictionaries include parameters that are explicitly consumed
| by SQLAlchemy Core or ORM, as well as arbitrary keyword arguments not
| defined by SQLAlchemy, which means the methods and/or parameter
| dictionaries may be used for user-defined parameters that interact with
| custom code, which may access the parameters using methods such as
| :meth:`_sql.Executable.get_execution_options` and
| :meth:`_engine.Connection.get_execution_options`, or within selected
| event hooks using a dedicated ``execution_options`` event parameter
| such as
| :paramref:`_events.ConnectionEvents.before_execute.execution_options`
| or :attr:`_orm.ORMExecuteState.execution_options`, e.g.::
|
| from sqlalchemy import event
|
|
| @event.listens_for(some_engine, "before_execute")
| def _process_opt(conn, statement, multiparams, params, execution_options):
| "run a SQL function before invoking a statement"
|
| if execution_options.get("do_special_thing", False):
| conn.exec_driver_sql("run_special_function()")
|
| Within the scope of options that are explicitly recognized by
| SQLAlchemy, most apply to specific classes of objects and not others.
| The most common execution options include:
|
| * :paramref:`_engine.Connection.execution_options.isolation_level` -
| sets the isolation level for a connection or a class of connections
| via an :class:`_engine.Engine`. This option is accepted only
| by :class:`_engine.Connection` or :class:`_engine.Engine`.
|
| * :paramref:`_engine.Connection.execution_options.stream_results` -
| indicates results should be fetched using a server side cursor;
| this option is accepted by :class:`_engine.Connection`, by the
| :paramref:`_engine.Connection.execute.execution_options` parameter
| on :meth:`_engine.Connection.execute`, and additionally by
| :meth:`_sql.Executable.execution_options` on a SQL statement object,
| as well as by ORM constructs like :meth:`_orm.Session.execute`.
|
| * :paramref:`_engine.Connection.execution_options.compiled_cache` -
| indicates a dictionary that will serve as the
| :ref:`SQL compilation cache <sql_caching>`
| for a :class:`_engine.Connection` or :class:`_engine.Engine`, as
| well as for ORM methods like :meth:`_orm.Session.execute`.
| Can be passed as ``None`` to disable caching for statements.
| This option is not accepted by
| :meth:`_sql.Executable.execution_options` as it is inadvisable to
| carry along a compilation cache within a statement object.
|
| * :paramref:`_engine.Connection.execution_options.schema_translate_map`
| - a mapping of schema names used by the
| :ref:`Schema Translate Map <schema_translating>` feature, accepted
| by :class:`_engine.Connection`, :class:`_engine.Engine`,
| :class:`_sql.Executable`, as well as by ORM constructs
| like :meth:`_orm.Session.execute`.
|
| .. seealso::
|
| :meth:`_engine.Connection.execution_options`
|
| :paramref:`_engine.Connection.execute.execution_options`
|
| :paramref:`_orm.Session.execute.execution_options`
|
| :ref:`orm_queryguide_execution_options` - documentation on all
| ORM-specific execution options
|
| get_execution_options(self) -> '_ExecuteOptions'
| Get the non-SQL options which will take effect during execution.
|
| .. versionadded:: 1.3
|
| .. seealso::
|
| :meth:`.Executable.execution_options`
|
| options(self, *options: 'ExecutableOption') -> 'Self'
| Apply options to this statement.
|
| In the general sense, options are any kind of Python object
| that can be interpreted by the SQL compiler for the statement.
| These options can be consumed by specific dialects or specific kinds
| of compilers.
|
| The most commonly known kind of option are the ORM level options
| that apply "eager load" and other loading behaviors to an ORM
| query. However, options can theoretically be used for many other
| purposes.
|
| For background on specific kinds of options for specific kinds of
| statements, refer to the documentation for those option objects.
|
| .. versionchanged:: 1.4 - added :meth:`.Executable.options` to
| Core statement objects towards the goal of allowing unified
| Core / ORM querying capabilities.
|
| .. seealso::
|
| :ref:`loading_columns` - refers to options specific to the usage
| of ORM queries
|
| :ref:`relationship_loader_options` - refers to options specific
| to the usage of ORM queries
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.base.Executable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.Executable:
|
| is_delete = False
|
| is_dml = False
|
| is_from_statement = False
|
| is_insert = False
|
| is_select = False
|
| is_text = False
|
| is_update = False
|
| supports_execution = True
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.roles.SQLRole:
|
| allows_lambda = False
|
| uses_inspection = False
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Computed
Python Library Documentation: class Computed in module sqlalchemy.sql.schema
class Computed(FetchedValue, SchemaItem)
| Computed(sqltext: '_DDLColumnArgument', persisted: 'Optional[bool]' = None) -> 'None'
|
| Defines a generated column, i.e. "GENERATED ALWAYS AS" syntax.
|
| The :class:`.Computed` construct is an inline construct added to the
| argument list of a :class:`_schema.Column` object::
|
| from sqlalchemy import Computed
|
| Table(
| "square",
| metadata_obj,
| Column("side", Float, nullable=False),
| Column("area", Float, Computed("side * side")),
| )
|
| See the linked documentation below for complete details.
|
| .. versionadded:: 1.3.11
|
| .. seealso::
|
| :ref:`computed_ddl`
|
| Method resolution order:
| Computed
| FetchedValue
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __init__(self, sqltext: '_DDLColumnArgument', persisted: 'Optional[bool]' = None) -> 'None'
| Construct a GENERATED ALWAYS AS DDL construct to accompany a
| :class:`_schema.Column`.
|
| :param sqltext:
| A string containing the column generation expression, which will be
| used verbatim, or a SQL expression construct, such as a
| :func:`_expression.text`
| object. If given as a string, the object is converted to a
| :func:`_expression.text` object.
|
| .. warning:: The :paramref:`.Computed.sqltext` argument to :class:`.Computed` can be passed as a Python string argument, which will be treated as **trusted SQL text** and rendered as given. **DO NOT PASS UNTRUSTED INPUT TO THIS PARAMETER**.
|
|
|
| :param persisted:
| Optional, controls how this column should be persisted by the
| database. Possible values are:
|
| * ``None``, the default, it will use the default persistence
| defined by the database.
| * ``True``, will render ``GENERATED ALWAYS AS ... STORED``, or the
| equivalent for the target database if supported.
| * ``False``, will render ``GENERATED ALWAYS AS ... VIRTUAL``, or
| the equivalent for the target database if supported.
|
| Specifying ``True`` or ``False`` may raise an error when the DDL
| is emitted to the target database if the database does not support
| that persistence option. Leaving this parameter at its default
| of ``None`` is guaranteed to succeed for all databases that support
| ``GENERATED ALWAYS AS``.
|
| copy(self, *, target_table: 'Optional[Table]' = None, **kw: 'Any') -> 'Computed'
| .. deprecated:: 1.4 The :meth:`_schema.Computed.copy` method is deprecated and will be removed in a future release.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'column': 'Optional[Column[Any]]'}
|
| __visit_name__ = 'computed_column'
|
| ----------------------------------------------------------------------
| Methods inherited from FetchedValue:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from FetchedValue:
|
| has_argument = False
|
| is_clause_element = False
|
| is_identity = False
|
| is_server_default = True
|
| reflected = False
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Constraint
Python Library Documentation: class Constraint in module sqlalchemy.sql.schema
class Constraint(sqlalchemy.sql.base.DialectKWArgs, HasConditionalDDL, SchemaItem)
| Constraint(name: '_ConstraintNameArgument' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, info: 'Optional[_InfoType]' = None, comment: 'Optional[str]' = None, _create_rule: 'Optional[Any]' = None, _type_bound: 'bool' = False, **dialect_kw: 'Any') -> 'None'
|
| A table-level SQL constraint.
|
| :class:`_schema.Constraint` serves as the base class for the series of
| constraint objects that can be associated with :class:`_schema.Table`
| objects, including :class:`_schema.PrimaryKeyConstraint`,
| :class:`_schema.ForeignKeyConstraint`
| :class:`_schema.UniqueConstraint`, and
| :class:`_schema.CheckConstraint`.
|
| Method resolution order:
| Constraint
| sqlalchemy.sql.base.DialectKWArgs
| HasConditionalDDL
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __init__(self, name: '_ConstraintNameArgument' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, info: 'Optional[_InfoType]' = None, comment: 'Optional[str]' = None, _create_rule: 'Optional[Any]' = None, _type_bound: 'bool' = False, **dialect_kw: 'Any') -> 'None'
| Create a SQL constraint.
|
| :param name:
| Optional, the in-database name of this ``Constraint``.
|
| :param deferrable:
| Optional bool. If set, emit DEFERRABLE or NOT DEFERRABLE when
| issuing DDL for this constraint.
|
| :param initially:
| Optional string. If set, emit INITIALLY <value> when issuing DDL
| for this constraint.
|
| :param info: Optional data dictionary which will be populated into the
| :attr:`.SchemaItem.info` attribute of this object.
|
| :param comment: Optional string that will render an SQL comment on
| foreign key constraint creation.
|
| .. versionadded:: 2.0
|
| :param \**dialect_kw: Additional keyword arguments are dialect
| specific, and passed in the form ``<dialectname>_<argname>``. See
| the documentation regarding an individual dialect at
| :ref:`dialect_toplevel` for detail on documented arguments.
|
| :param _create_rule:
| used internally by some datatypes that also create constraints.
|
| :param _type_bound:
| used internally to indicate that this constraint is associated with
| a specific datatype.
|
| copy(self, **kw: 'Any') -> 'Self'
| .. deprecated:: 1.4 The :meth:`_schema.Constraint.copy` method is deprecated and will be removed in a future release.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| table
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'_column_flag': 'bool', '_creation_order': 'int'}
|
| __visit_name__ = 'constraint'
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_options(...)
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| This is a two-level nested registry, keyed to ``<dialect_name>``
| and ``<argument_name>``. For example, the ``postgresql_where``
| argument would be locatable as::
|
| arg = my_object.dialect_options["postgresql"]["where"]
|
| .. versionadded:: 0.9.2
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form
|
| get_dialect_option(self, dialect: 'Dialect', argument_name: 'str', *, else_: 'Any' = None, deprecated_fallback: 'Optional[str]' = None) -> 'Any'
| Return the value of a dialect-specific option, or *else_* if
| this dialect does not register the given argument.
|
| This is useful for DDL compilers that may be inherited by
| third-party dialects whose ``construct_arguments`` do not
| include the same set of keys as the parent dialect.
|
| :param dialect: The dialect for which to retrieve the option.
| :param argument_name: The name of the argument to retrieve.
| :param else\_: The value to return if the argument is not present.
| :param deprecated_fallback: Optional dialect name to fall back to
| if the argument is not present for the current dialect. If the
| argument is present for the fallback dialect but not the current
| dialect, a deprecation warning will be emitted.
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| argument_for(dialect_name: 'str', argument_name: 'str', default: 'Any') -> 'None'
| Add a new kind of dialect-specific keyword argument for this class.
|
| E.g.::
|
| Index.argument_for("mydialect", "length", None)
|
| some_index = Index("a", "b", mydialect_length=5)
|
| The :meth:`.DialectKWArgs.argument_for` method is a per-argument
| way adding extra arguments to the
| :attr:`.DefaultDialect.construct_arguments` dictionary. This
| dictionary provides a list of argument names accepted by various
| schema-level constructs on behalf of a dialect.
|
| New dialects should typically specify this dictionary all at once as a
| data member of the dialect class. The use case for ad-hoc addition of
| argument names is typically for end-user code that is also using
| a custom compilation scheme which consumes the additional arguments.
|
| :param dialect_name: name of a dialect. The dialect must be
| locatable, else a :class:`.NoSuchModuleError` is raised. The
| dialect must also include an existing
| :attr:`.DefaultDialect.construct_arguments` collection, indicating
| that it participates in the keyword-argument validation and default
| system, else :class:`.ArgumentError` is raised. If the dialect does
| not include this collection, then any keyword argument can be
| specified on behalf of this dialect already. All dialects packaged
| within SQLAlchemy include this collection, however for third party
| dialects, support may vary.
|
| :param argument_name: name of the parameter.
|
| :param default: default value of the parameter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_kwargs
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| The arguments are present here in their original ``<dialect>_<kwarg>``
| format. Only arguments that were actually passed are included;
| unlike the :attr:`.DialectKWArgs.dialect_options` collection, which
| contains all options known by this dialect including defaults.
|
| The collection is also writable; keys are accepted of the
| form ``<dialect>_<kwarg>`` where the value will be assembled
| into the list of options.
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_options` - nested dictionary form
|
| kwargs
| A synonym for :attr:`.DialectKWArgs.dialect_kwargs`.
|
| ----------------------------------------------------------------------
| Methods inherited from HasConditionalDDL:
|
| ddl_if(self, dialect: 'Optional[str]' = None, callable_: 'Optional[ddl.DDLIfCallable]' = None, state: 'Optional[Any]' = None) -> 'Self'
| apply a conditional DDL rule to this schema item.
|
| These rules work in a similar manner to the
| :meth:`.ExecutableDDLElement.execute_if` callable, with the added
| feature that the criteria may be checked within the DDL compilation
| phase for a construct such as :class:`.CreateTable`.
| :meth:`.HasConditionalDDL.ddl_if` currently applies towards the
| :class:`.Index` construct as well as all :class:`.Constraint`
| constructs.
|
| :param dialect: string name of a dialect, or a tuple of string names
| to indicate multiple dialect types.
|
| :param callable\_: a callable that is constructed using the same form
| as that described in
| :paramref:`.ExecutableDDLElement.execute_if.callable_`.
|
| :param state: any arbitrary object that will be passed to the
| callable, if present.
|
| .. versionadded:: 2.0
|
| .. seealso::
|
| :ref:`schema_ddl_ddl_if` - background and usage examples
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.DATE
Python Library Documentation: class DATE in module sqlalchemy.sql.sqltypes
class DATE(Date)
| The SQL DATE type.
|
| Method resolution order:
| DATE
| Date
| _RenderISO8601NoT
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'DATE'
|
| ----------------------------------------------------------------------
| Methods inherited from Date:
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Date:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _RenderISO8601NoT:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.DATETIME
Python Library Documentation: class DATETIME in module sqlalchemy.sql.sqltypes
class DATETIME(DateTime)
| DATETIME(timezone: 'bool' = False)
|
| The SQL DATETIME type.
|
| Method resolution order:
| DATETIME
| DateTime
| _RenderISO8601NoT
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'DATETIME'
|
| ----------------------------------------------------------------------
| Methods inherited from DateTime:
|
| __init__(self, timezone: 'bool' = False)
| Construct a new :class:`.DateTime`.
|
| :param timezone: boolean. Indicates that the datetime type should
| enable timezone support, if available on the
| **base date/time-holding type only**. It is recommended
| to make use of the :class:`_types.TIMESTAMP` datatype directly when
| using this flag, as some databases include separate generic
| date/time-holding types distinct from the timezone-capable
| TIMESTAMP datatype, such as Oracle Database.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from DateTime:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _RenderISO8601NoT:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.DDL
Python Library Documentation: class DDL in module sqlalchemy.sql.ddl
class DDL(ExecutableDDLElement)
| DDL(statement, context=None)
|
| A literal DDL statement.
|
| Specifies literal SQL DDL to be executed by the database. DDL objects
| function as DDL event listeners, and can be subscribed to those events
| listed in :class:`.DDLEvents`, using either :class:`_schema.Table` or
| :class:`_schema.MetaData` objects as targets.
| Basic templating support allows
| a single DDL instance to handle repetitive tasks for multiple tables.
|
| Examples::
|
| from sqlalchemy import event, DDL
|
| tbl = Table("users", metadata, Column("uid", Integer))
| event.listen(tbl, "before_create", DDL("DROP TRIGGER users_trigger"))
|
| spow = DDL("ALTER TABLE %(table)s SET secretpowers TRUE")
| event.listen(tbl, "after_create", spow.execute_if(dialect="somedb"))
|
| drop_spow = DDL("ALTER TABLE users SET secretpowers FALSE")
| connection.execute(drop_spow)
|
| When operating on Table events, the following ``statement``
| string substitutions are available:
|
| .. sourcecode:: text
|
| %(table)s - the Table name, with any required quoting applied
| %(schema)s - the schema name, with any required quoting applied
| %(fullname)s - the Table name including schema, quoted if needed
|
| The DDL's "context", if any, will be combined with the standard
| substitutions noted above. Keys present in the context will override
| the standard substitutions.
|
| Method resolution order:
| DDL
| ExecutableDDLElement
| sqlalchemy.sql.roles.DDLRole
| sqlalchemy.sql.base.Executable
| sqlalchemy.sql.roles.StatementRole
| sqlalchemy.sql.roles.SQLRole
| BaseDDLElement
| sqlalchemy.sql.elements.ClauseElement
| sqlalchemy.sql.annotation.SupportsWrappingAnnotations
| sqlalchemy.sql.annotation.SupportsAnnotations
| sqlalchemy.sql.cache_key.MemoizedHasCacheKey
| sqlalchemy.sql.cache_key.HasCacheKey
| sqlalchemy.util.langhelpers.HasMemoized
| sqlalchemy.sql.traversals.HasCopyInternals
| sqlalchemy.sql.visitors.ExternallyTraversible
| sqlalchemy.sql.visitors.HasTraverseInternals
| sqlalchemy.sql.elements.CompilerElement
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __init__(self, statement, context=None)
| Create a DDL statement.
|
| :param statement:
| A string or unicode string to be executed. Statements will be
| processed with Python's string formatting operator using
| a fixed set of string substitutions, as well as additional
| substitutions provided by the optional :paramref:`.DDL.context`
| parameter.
|
| A literal '%' in a statement must be escaped as '%%'.
|
| SQL bind parameters are not available in DDL statements.
|
| :param context:
| Optional dictionary, defaults to None. These values will be
| available for use in string substitutions on the DDL statement.
|
| .. seealso::
|
| :class:`.DDLEvents`
|
| :ref:`event_toplevel`
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __visit_name__ = 'ddl'
|
| ----------------------------------------------------------------------
| Methods inherited from ExecutableDDLElement:
|
| __call__(self, target, bind, **kw)
| Execute the DDL as a ddl_listener.
|
| against(self, target: 'SchemaItem') -> 'Self'
| Return a copy of this :class:`_schema.ExecutableDDLElement` which
| will include the given target.
|
| This essentially applies the given item to the ``.target`` attribute of
| the returned :class:`_schema.ExecutableDDLElement` object. This target
| is then usable by event handlers and compilation routines in order to
| provide services such as tokenization of a DDL string in terms of a
| particular :class:`_schema.Table`.
|
| When a :class:`_schema.ExecutableDDLElement` object is established as
| an event handler for the :meth:`_events.DDLEvents.before_create` or
| :meth:`_events.DDLEvents.after_create` events, and the event then
| occurs for a given target such as a :class:`_schema.Constraint` or
| :class:`_schema.Table`, that target is established with a copy of the
| :class:`_schema.ExecutableDDLElement` object using this method, which
| then proceeds to the :meth:`_schema.ExecutableDDLElement.execute`
| method in order to invoke the actual DDL instruction.
|
| :param target: a :class:`_schema.SchemaItem` that will be the subject
| of a DDL operation.
|
| :return: a copy of this :class:`_schema.ExecutableDDLElement` with the
| ``.target`` attribute assigned to the given
| :class:`_schema.SchemaItem`.
|
| .. seealso::
|
| :class:`_schema.DDL` - uses tokenization against the "target" when
| processing the DDL string.
|
| execute_if(self, dialect: 'Optional[str]' = None, callable_: 'Optional[DDLIfCallable]' = None, state: 'Optional[Any]' = None) -> 'Self'
| Return a callable that will execute this
| :class:`_ddl.ExecutableDDLElement` conditionally within an event
| handler.
|
| Used to provide a wrapper for event listening::
|
| event.listen(
| metadata,
| "before_create",
| DDL("my_ddl").execute_if(dialect="postgresql"),
| )
|
| :param dialect: May be a string or tuple of strings.
| If a string, it will be compared to the name of the
| executing database dialect::
|
| DDL("something").execute_if(dialect="postgresql")
|
| If a tuple, specifies multiple dialect names::
|
| DDL("something").execute_if(dialect=("postgresql", "mysql"))
|
| :param callable\_: A callable, which will be invoked with
| three positional arguments as well as optional keyword
| arguments:
|
| :ddl:
| This DDL element.
|
| :target:
| The :class:`_schema.Table` or :class:`_schema.MetaData`
| object which is the
| target of this event. May be None if the DDL is executed
| explicitly.
|
| :bind:
| The :class:`_engine.Connection` being used for DDL execution.
| May be None if this construct is being created inline within
| a table, in which case ``compiler`` will be present.
|
| :tables:
| Optional keyword argument - a list of Table objects which are to
| be created/ dropped within a MetaData.create_all() or drop_all()
| method call.
|
| :dialect: keyword argument, but always present - the
| :class:`.Dialect` involved in the operation.
|
| :compiler: keyword argument. Will be ``None`` for an engine
| level DDL invocation, but will refer to a :class:`.DDLCompiler`
| if this DDL element is being created inline within a table.
|
| :state:
| Optional keyword argument - will be the ``state`` argument
| passed to this function.
|
| :checkfirst:
| Keyword argument, will be True if the 'checkfirst' flag was
| set during the call to ``create()``, ``create_all()``,
| ``drop()``, ``drop_all()``.
|
| If the callable returns a True value, the DDL statement will be
| executed.
|
| :param state: any value which will be passed to the callable\_
| as the ``state`` keyword argument.
|
| .. seealso::
|
| :meth:`.SchemaItem.ddl_if`
|
| :class:`.DDLEvents`
|
| :ref:`event_toplevel`
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ExecutableDDLElement:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ExecutableDDLElement:
|
| target = None
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.Executable:
|
| execution_options(self, **kw: 'Any') -> 'Self'
| Set non-SQL options for the statement which take effect during
| execution.
|
| Execution options can be set at many scopes, including per-statement,
| per-connection, or per execution, using methods such as
| :meth:`_engine.Connection.execution_options` and parameters which
| accept a dictionary of options such as
| :paramref:`_engine.Connection.execute.execution_options` and
| :paramref:`_orm.Session.execute.execution_options`.
|
| The primary characteristic of an execution option, as opposed to
| other kinds of options such as ORM loader options, is that
| **execution options never affect the compiled SQL of a query, only
| things that affect how the SQL statement itself is invoked or how
| results are fetched**. That is, execution options are not part of
| what's accommodated by SQL compilation nor are they considered part of
| the cached state of a statement.
|
| The :meth:`_sql.Executable.execution_options` method is
| :term:`generative`, as
| is the case for the method as applied to the :class:`_engine.Engine`
| and :class:`_orm.Query` objects, which means when the method is called,
| a copy of the object is returned, which applies the given parameters to
| that new copy, but leaves the original unchanged::
|
| statement = select(table.c.x, table.c.y)
| new_statement = statement.execution_options(my_option=True)
|
| An exception to this behavior is the :class:`_engine.Connection`
| object, where the :meth:`_engine.Connection.execution_options` method
| is explicitly **not** generative.
|
| The kinds of options that may be passed to
| :meth:`_sql.Executable.execution_options` and other related methods and
| parameter dictionaries include parameters that are explicitly consumed
| by SQLAlchemy Core or ORM, as well as arbitrary keyword arguments not
| defined by SQLAlchemy, which means the methods and/or parameter
| dictionaries may be used for user-defined parameters that interact with
| custom code, which may access the parameters using methods such as
| :meth:`_sql.Executable.get_execution_options` and
| :meth:`_engine.Connection.get_execution_options`, or within selected
| event hooks using a dedicated ``execution_options`` event parameter
| such as
| :paramref:`_events.ConnectionEvents.before_execute.execution_options`
| or :attr:`_orm.ORMExecuteState.execution_options`, e.g.::
|
| from sqlalchemy import event
|
|
| @event.listens_for(some_engine, "before_execute")
| def _process_opt(conn, statement, multiparams, params, execution_options):
| "run a SQL function before invoking a statement"
|
| if execution_options.get("do_special_thing", False):
| conn.exec_driver_sql("run_special_function()")
|
| Within the scope of options that are explicitly recognized by
| SQLAlchemy, most apply to specific classes of objects and not others.
| The most common execution options include:
|
| * :paramref:`_engine.Connection.execution_options.isolation_level` -
| sets the isolation level for a connection or a class of connections
| via an :class:`_engine.Engine`. This option is accepted only
| by :class:`_engine.Connection` or :class:`_engine.Engine`.
|
| * :paramref:`_engine.Connection.execution_options.stream_results` -
| indicates results should be fetched using a server side cursor;
| this option is accepted by :class:`_engine.Connection`, by the
| :paramref:`_engine.Connection.execute.execution_options` parameter
| on :meth:`_engine.Connection.execute`, and additionally by
| :meth:`_sql.Executable.execution_options` on a SQL statement object,
| as well as by ORM constructs like :meth:`_orm.Session.execute`.
|
| * :paramref:`_engine.Connection.execution_options.compiled_cache` -
| indicates a dictionary that will serve as the
| :ref:`SQL compilation cache <sql_caching>`
| for a :class:`_engine.Connection` or :class:`_engine.Engine`, as
| well as for ORM methods like :meth:`_orm.Session.execute`.
| Can be passed as ``None`` to disable caching for statements.
| This option is not accepted by
| :meth:`_sql.Executable.execution_options` as it is inadvisable to
| carry along a compilation cache within a statement object.
|
| * :paramref:`_engine.Connection.execution_options.schema_translate_map`
| - a mapping of schema names used by the
| :ref:`Schema Translate Map <schema_translating>` feature, accepted
| by :class:`_engine.Connection`, :class:`_engine.Engine`,
| :class:`_sql.Executable`, as well as by ORM constructs
| like :meth:`_orm.Session.execute`.
|
| .. seealso::
|
| :meth:`_engine.Connection.execution_options`
|
| :paramref:`_engine.Connection.execute.execution_options`
|
| :paramref:`_orm.Session.execute.execution_options`
|
| :ref:`orm_queryguide_execution_options` - documentation on all
| ORM-specific execution options
|
| get_execution_options(self) -> '_ExecuteOptions'
| Get the non-SQL options which will take effect during execution.
|
| .. versionadded:: 1.3
|
| .. seealso::
|
| :meth:`.Executable.execution_options`
|
| options(self, *options: 'ExecutableOption') -> 'Self'
| Apply options to this statement.
|
| In the general sense, options are any kind of Python object
| that can be interpreted by the SQL compiler for the statement.
| These options can be consumed by specific dialects or specific kinds
| of compilers.
|
| The most commonly known kind of option are the ORM level options
| that apply "eager load" and other loading behaviors to an ORM
| query. However, options can theoretically be used for many other
| purposes.
|
| For background on specific kinds of options for specific kinds of
| statements, refer to the documentation for those option objects.
|
| .. versionchanged:: 1.4 - added :meth:`.Executable.options` to
| Core statement objects towards the goal of allowing unified
| Core / ORM querying capabilities.
|
| .. seealso::
|
| :ref:`loading_columns` - refers to options specific to the usage
| of ORM queries
|
| :ref:`relationship_loader_options` - refers to options specific
| to the usage of ORM queries
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.Executable:
|
| is_delete = False
|
| is_dml = False
|
| is_from_statement = False
|
| is_insert = False
|
| is_select = False
|
| is_text = False
|
| is_update = False
|
| supports_execution = True
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.roles.SQLRole:
|
| allows_lambda = False
|
| uses_inspection = False
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.elements.ClauseElement:
|
| __bool__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __invert__(self)
|
| compare(self, other: 'ClauseElement', **kw: 'Any') -> 'bool'
| Compare this :class:`_expression.ClauseElement` to
| the given :class:`_expression.ClauseElement`.
|
| Subclasses should override the default behavior, which is a
| straight identity comparison.
|
| \**kw are arguments consumed by subclass ``compare()`` methods and
| may be used to modify the criteria for comparison
| (see :class:`_expression.ColumnElement`).
|
| description(...)
|
| entity_namespace(...)
|
| params(self, _ClauseElement__optionaldict: 'Optional[Mapping[str, Any]]' = None, **kwargs: 'Any') -> 'Self'
| Return a copy with :func:`_expression.bindparam` elements
| replaced.
|
| Returns a copy of this ClauseElement with
| :func:`_expression.bindparam`
| elements replaced with values taken from the given dictionary::
|
| >>> clause = column("x") + bindparam("foo")
| >>> print(clause.compile().params)
| {'foo':None}
| >>> print(clause.params({"foo": 7}).compile().params)
| {'foo':7}
|
| self_group(self, against: 'Optional[OperatorType]' = None) -> 'ClauseElement'
| Apply a 'grouping' to this :class:`_expression.ClauseElement`.
|
| This method is overridden by subclasses to return a "grouping"
| construct, i.e. parenthesis. In particular it's used by "binary"
| expressions to provide a grouping around themselves when placed into a
| larger expression, as well as by :func:`_expression.select`
| constructs when placed into the FROM clause of another
| :func:`_expression.select`. (Note that subqueries should be
| normally created using the :meth:`_expression.Select.alias` method,
| as many
| platforms require nested SELECT statements to be named).
|
| As expressions are composed together, the application of
| :meth:`self_group` is automatic - end-user code should never
| need to use this method directly. Note that SQLAlchemy's
| clause constructs take operator precedence into account -
| so parenthesis might not be needed, for example, in
| an expression like ``x OR (y AND z)`` - AND takes precedence
| over OR.
|
| The base :meth:`self_group` method of
| :class:`_expression.ClauseElement`
| just returns self.
|
| unique_params(self, _ClauseElement__optionaldict: 'Optional[Dict[str, Any]]' = None, **kwargs: 'Any') -> 'Self'
| Return a copy with :func:`_expression.bindparam` elements
| replaced.
|
| Same functionality as :meth:`_expression.ClauseElement.params`,
| except adds `unique=True`
| to affected bind parameters so that multiple statements can be
| used.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.elements.ClauseElement:
|
| is_clause_element = True
|
| is_selectable = False
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.cache_key.HasCacheKey:
|
| inherit_cache = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.util.langhelpers.HasMemoized:
|
| memoized_instancemethod(fn: '_F') -> '_F'
| Decorate a method memoize its return value.
|
| :meta private:
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.util.langhelpers.HasMemoized:
|
| memoized_attribute = <class 'sqlalchemy.util.langhelpers.HasMemoized.m...
| A read-only @property that is only evaluated once.
|
| :meta private:
|
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.visitors.HasTraverseInternals:
|
| get_children(self, *, omit_attrs: 'Tuple[str, ...]' = (), **kw: 'Any') -> 'Iterable[HasTraverseInternals]'
| Return immediate child :class:`.visitors.HasTraverseInternals`
| elements of this :class:`.visitors.HasTraverseInternals`.
|
| This is used for visit traversal.
|
| \**kw may contain flags that change the collection that is
| returned, for example to return a subset of items in order to
| cut down on larger traversals, or to return child items from a
| different context (such as schema-level collections instead of
| clause-level).
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.elements.CompilerElement:
|
| __str__(self) -> 'str'
| Return str(self).
|
| compile(self, bind: 'Optional[_HasDialect]' = None, dialect: 'Optional[Dialect]' = None, **kw: 'Any') -> 'Compiled'
| Compile this SQL expression.
|
| The return value is a :class:`~.Compiled` object.
| Calling ``str()`` or ``unicode()`` on the returned value will yield a
| string representation of the result. The
| :class:`~.Compiled` object also can return a
| dictionary of bind parameter names and values
| using the ``params`` accessor.
|
| :param bind: An :class:`.Connection` or :class:`.Engine` which
| can provide a :class:`.Dialect` in order to generate a
| :class:`.Compiled` object. If the ``bind`` and
| ``dialect`` parameters are both omitted, a default SQL compiler
| is used.
|
| :param column_keys: Used for INSERT and UPDATE statements, a list of
| column names which should be present in the VALUES clause of the
| compiled statement. If ``None``, all columns from the target table
| object are rendered.
|
| :param dialect: A :class:`.Dialect` instance which can generate
| a :class:`.Compiled` object. This argument takes precedence over
| the ``bind`` argument.
|
| :param compile_kwargs: optional dictionary of additional parameters
| that will be passed through to the compiler within all "visit"
| methods. This allows any custom flag to be passed through to
| a custom compilation construct, for example. It is also used
| for the case of passing the ``literal_binds`` flag through::
|
| from sqlalchemy.sql import table, column, select
|
| t = table("t", column("x"))
|
| s = select(t).where(t.c.x == 5)
|
| print(s.compile(compile_kwargs={"literal_binds": True}))
|
| .. seealso::
|
| :ref:`faq_sql_expression_string`
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.elements.CompilerElement:
|
| stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.DECIMAL
Python Library Documentation: class DECIMAL in module sqlalchemy.sql.sqltypes
class DECIMAL(Numeric)
| DECIMAL(precision: 'Optional[int]' = None, scale: 'Optional[int]' = None, decimal_return_scale: 'Optional[int]' = None, asdecimal: 'bool' = True)
|
| The SQL DECIMAL type.
|
| .. seealso::
|
| :class:`_types.Numeric` - documentation for the base type.
|
| Method resolution order:
| DECIMAL
| Numeric
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'DECIMAL'
|
| ----------------------------------------------------------------------
| Methods inherited from Numeric:
|
| __init__(self, precision: 'Optional[int]' = None, scale: 'Optional[int]' = None, decimal_return_scale: 'Optional[int]' = None, asdecimal: 'bool' = True)
| Construct a Numeric.
|
| :param precision: the numeric precision for use in DDL ``CREATE
| TABLE``.
|
| :param scale: the numeric scale for use in DDL ``CREATE TABLE``.
|
| :param asdecimal: default True. Return whether or not
| values should be sent as Python Decimal objects, or
| as floats. Different DBAPIs send one or the other based on
| datatypes - the Numeric type will ensure that return values
| are one or the other across DBAPIs consistently.
|
| :param decimal_return_scale: Default scale to use when converting
| from floats to Python decimals. Floating point values will typically
| be much longer due to decimal inaccuracy, and most floating point
| database types don't have a notion of "scale", so by default the
| float type looks for the first ten decimal places when converting.
| Specifying this value will override that length. Types which
| do include an explicit ".scale" value, such as the base
| :class:`.Numeric` as well as the MySQL float types, will use the
| value of ".scale" as the default for decimal_return_scale, if not
| otherwise specified.
|
| When using the ``Numeric`` type, care should be taken to ensure
| that the asdecimal setting is appropriate for the DBAPI in use -
| when Numeric applies a conversion from Decimal->float or float->
| Decimal, this conversion incurs an additional performance overhead
| for all result columns received.
|
| DBAPIs that return Decimal natively (e.g. psycopg2) will have
| better accuracy and higher performance with a setting of ``True``,
| as the native translation to Decimal reduces the amount of floating-
| point issues at play, and the Numeric type itself doesn't need
| to apply any further conversions. However, another DBAPI which
| returns floats natively *will* incur an additional conversion
| overhead, and is still subject to floating point data loss - in
| which case ``asdecimal=False`` will at least remove the extra
| conversion overhead.
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Numeric:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.DOUBLE
Python Library Documentation: class DOUBLE in module sqlalchemy.sql.sqltypes
class DOUBLE(Double)
| DOUBLE(precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
|
| The SQL DOUBLE type.
|
| .. versionadded:: 2.0
|
| .. seealso::
|
| :class:`_types.Double` - documentation for the base type.
|
| Method resolution order:
| DOUBLE
| Double
| Float
| Numeric
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'DOUBLE'
|
| ----------------------------------------------------------------------
| Methods inherited from Float:
|
| __init__(self: 'Float[_N]', precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
| Construct a Float.
|
| :param precision: the numeric precision for use in DDL ``CREATE
| TABLE``. Backends **should** attempt to ensure this precision
| indicates a number of digits for the generic
| :class:`_sqltypes.Float` datatype.
|
| .. note:: For the Oracle Database backend, the
| :paramref:`_sqltypes.Float.precision` parameter is not accepted
| when rendering DDL, as Oracle Database does not support float precision
| specified as a number of decimal places. Instead, use the
| Oracle Database-specific :class:`_oracle.FLOAT` datatype and specify the
| :paramref:`_oracle.FLOAT.binary_precision` parameter. This is new
| in version 2.0 of SQLAlchemy.
|
| To create a database agnostic :class:`_types.Float` that
| separately specifies binary precision for Oracle Database, use
| :meth:`_types.TypeEngine.with_variant` as follows::
|
| from sqlalchemy import Column
| from sqlalchemy import Float
| from sqlalchemy.dialects import oracle
|
| Column(
| "float_data",
| Float(5).with_variant(oracle.FLOAT(binary_precision=16), "oracle"),
| )
|
| :param asdecimal: the same flag as that of :class:`.Numeric`, but
| defaults to ``False``. Note that setting this flag to ``True``
| results in floating point conversion.
|
| :param decimal_return_scale: Default scale to use when converting
| from floats to Python decimals. Floating point values will typically
| be much longer due to decimal inaccuracy, and most floating point
| database types don't have a notion of "scale", so by default the
| float type looks for the first ten decimal places when converting.
| Specifying this value will override that length. Note that the
| MySQL float types, which do include "scale", will use "scale"
| as the default for decimal_return_scale, if not otherwise specified.
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Float:
|
| scale = None
|
| ----------------------------------------------------------------------
| Methods inherited from Numeric:
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Numeric:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.DOUBLE_PRECISION
Python Library Documentation: class DOUBLE_PRECISION in module sqlalchemy.sql.sqltypes
class DOUBLE_PRECISION(Double)
| DOUBLE_PRECISION(precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
|
| The SQL DOUBLE PRECISION type.
|
| .. versionadded:: 2.0
|
| .. seealso::
|
| :class:`_types.Double` - documentation for the base type.
|
| Method resolution order:
| DOUBLE_PRECISION
| Double
| Float
| Numeric
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'DOUBLE_PRECISION'
|
| ----------------------------------------------------------------------
| Methods inherited from Float:
|
| __init__(self: 'Float[_N]', precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
| Construct a Float.
|
| :param precision: the numeric precision for use in DDL ``CREATE
| TABLE``. Backends **should** attempt to ensure this precision
| indicates a number of digits for the generic
| :class:`_sqltypes.Float` datatype.
|
| .. note:: For the Oracle Database backend, the
| :paramref:`_sqltypes.Float.precision` parameter is not accepted
| when rendering DDL, as Oracle Database does not support float precision
| specified as a number of decimal places. Instead, use the
| Oracle Database-specific :class:`_oracle.FLOAT` datatype and specify the
| :paramref:`_oracle.FLOAT.binary_precision` parameter. This is new
| in version 2.0 of SQLAlchemy.
|
| To create a database agnostic :class:`_types.Float` that
| separately specifies binary precision for Oracle Database, use
| :meth:`_types.TypeEngine.with_variant` as follows::
|
| from sqlalchemy import Column
| from sqlalchemy import Float
| from sqlalchemy.dialects import oracle
|
| Column(
| "float_data",
| Float(5).with_variant(oracle.FLOAT(binary_precision=16), "oracle"),
| )
|
| :param asdecimal: the same flag as that of :class:`.Numeric`, but
| defaults to ``False``. Note that setting this flag to ``True``
| results in floating point conversion.
|
| :param decimal_return_scale: Default scale to use when converting
| from floats to Python decimals. Floating point values will typically
| be much longer due to decimal inaccuracy, and most floating point
| database types don't have a notion of "scale", so by default the
| float type looks for the first ten decimal places when converting.
| Specifying this value will override that length. Note that the
| MySQL float types, which do include "scale", will use "scale"
| as the default for decimal_return_scale, if not otherwise specified.
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Float:
|
| scale = None
|
| ----------------------------------------------------------------------
| Methods inherited from Numeric:
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Numeric:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Date
Python Library Documentation: class Date in module sqlalchemy.sql.sqltypes
class Date(_RenderISO8601NoT, HasExpressionLookup, sqlalchemy.sql.type_api.TypeEngine)
| A type for ``datetime.date()`` objects.
|
| Method resolution order:
| Date
| _RenderISO8601NoT
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'date'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _RenderISO8601NoT:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.DateTime
Python Library Documentation: class DateTime in module sqlalchemy.sql.sqltypes
class DateTime(_RenderISO8601NoT, HasExpressionLookup, sqlalchemy.sql.type_api.TypeEngine)
| DateTime(timezone: 'bool' = False)
|
| A type for ``datetime.datetime()`` objects.
|
| Date and time types return objects from the Python ``datetime``
| module. Most DBAPIs have built in support for the datetime
| module, with the noted exception of SQLite. In the case of
| SQLite, date and time types are stored as strings which are then
| converted back to datetime objects when rows are returned.
|
| For the time representation within the datetime type, some
| backends include additional options, such as timezone support and
| fractional seconds support. For fractional seconds, use the
| dialect-specific datatype, such as :class:`.mysql.TIME`. For
| timezone support, use at least the :class:`_types.TIMESTAMP` datatype,
| if not the dialect-specific datatype object.
|
| Method resolution order:
| DateTime
| _RenderISO8601NoT
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, timezone: 'bool' = False)
| Construct a new :class:`.DateTime`.
|
| :param timezone: boolean. Indicates that the datetime type should
| enable timezone support, if available on the
| **base date/time-holding type only**. It is recommended
| to make use of the :class:`_types.TIMESTAMP` datatype directly when
| using this flag, as some databases include separate generic
| date/time-holding types distinct from the timezone-capable
| TIMESTAMP datatype, such as Oracle Database.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'datetime'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _RenderISO8601NoT:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.DefaultClause
Python Library Documentation: class DefaultClause in module sqlalchemy.sql.schema
class DefaultClause(FetchedValue)
| DefaultClause(arg: 'Union[str, ClauseElement, TextClause]', for_update: 'bool' = False, _reflected: 'bool' = False) -> 'None'
|
| A DDL-specified DEFAULT column value.
|
| :class:`.DefaultClause` is a :class:`.FetchedValue`
| that also generates a "DEFAULT" clause when
| "CREATE TABLE" is emitted.
|
| :class:`.DefaultClause` is generated automatically
| whenever the ``server_default``, ``server_onupdate`` arguments of
| :class:`_schema.Column` are used. A :class:`.DefaultClause`
| can be passed positionally as well.
|
| For example, the following::
|
| Column("foo", Integer, server_default="50")
|
| Is equivalent to::
|
| Column("foo", Integer, DefaultClause("50"))
|
| Method resolution order:
| DefaultClause
| FetchedValue
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| builtins.object
|
| Methods defined here:
|
| __init__(self, arg: 'Union[str, ClauseElement, TextClause]', for_update: 'bool' = False, _reflected: 'bool' = False) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| has_argument = True
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from FetchedValue:
|
| is_clause_element = False
|
| is_identity = False
|
| is_server_default = True
|
| reflected = False
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
sqlmodel.Double
Python Library Documentation: class Double in module sqlalchemy.sql.sqltypes
class Double(Float)
| Double(precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
|
| A type for double ``FLOAT`` floating point types.
|
| Typically generates a ``DOUBLE`` or ``DOUBLE_PRECISION`` in DDL,
| and otherwise acts like a normal :class:`.Float` on the Python
| side.
|
| .. versionadded:: 2.0
|
| Method resolution order:
| Double
| Float
| Numeric
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'double'
|
| ----------------------------------------------------------------------
| Methods inherited from Float:
|
| __init__(self: 'Float[_N]', precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
| Construct a Float.
|
| :param precision: the numeric precision for use in DDL ``CREATE
| TABLE``. Backends **should** attempt to ensure this precision
| indicates a number of digits for the generic
| :class:`_sqltypes.Float` datatype.
|
| .. note:: For the Oracle Database backend, the
| :paramref:`_sqltypes.Float.precision` parameter is not accepted
| when rendering DDL, as Oracle Database does not support float precision
| specified as a number of decimal places. Instead, use the
| Oracle Database-specific :class:`_oracle.FLOAT` datatype and specify the
| :paramref:`_oracle.FLOAT.binary_precision` parameter. This is new
| in version 2.0 of SQLAlchemy.
|
| To create a database agnostic :class:`_types.Float` that
| separately specifies binary precision for Oracle Database, use
| :meth:`_types.TypeEngine.with_variant` as follows::
|
| from sqlalchemy import Column
| from sqlalchemy import Float
| from sqlalchemy.dialects import oracle
|
| Column(
| "float_data",
| Float(5).with_variant(oracle.FLOAT(binary_precision=16), "oracle"),
| )
|
| :param asdecimal: the same flag as that of :class:`.Numeric`, but
| defaults to ``False``. Note that setting this flag to ``True``
| results in floating point conversion.
|
| :param decimal_return_scale: Default scale to use when converting
| from floats to Python decimals. Floating point values will typically
| be much longer due to decimal inaccuracy, and most floating point
| database types don't have a notion of "scale", so by default the
| float type looks for the first ten decimal places when converting.
| Specifying this value will override that length. Note that the
| MySQL float types, which do include "scale", will use "scale"
| as the default for decimal_return_scale, if not otherwise specified.
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Float:
|
| scale = None
|
| ----------------------------------------------------------------------
| Methods inherited from Numeric:
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Numeric:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Enum
Python Library Documentation: class Enum in module sqlalchemy.sql.sqltypes
class Enum(String, SchemaType, sqlalchemy.sql.type_api.Emulated, sqlalchemy.sql.type_api.TypeEngine)
| Enum(*enums: 'Union[str, Type[enum.Enum]]', **kw: 'Any') -> 'None'
|
| Generic Enum Type.
|
| The :class:`.Enum` type provides a set of possible string values
| which the column is constrained towards.
|
| The :class:`.Enum` type will make use of the backend's native "ENUM"
| type if one is available; otherwise, it uses a VARCHAR datatype.
| An option also exists to automatically produce a CHECK constraint
| when the VARCHAR (so called "non-native") variant is produced;
| see the :paramref:`.Enum.create_constraint` flag.
|
| The :class:`.Enum` type also provides in-Python validation of string
| values during both read and write operations. When reading a value
| from the database in a result set, the string value is always checked
| against the list of possible values and a ``LookupError`` is raised
| if no match is found. When passing a value to the database as a
| plain string within a SQL statement, if the
| :paramref:`.Enum.validate_strings` parameter is
| set to True, a ``LookupError`` is raised for any string value that's
| not located in the given list of possible values; note that this
| impacts usage of LIKE expressions with enumerated values (an unusual
| use case).
|
| The source of enumerated values may be a list of string values, or
| alternatively a PEP-435-compliant enumerated class. For the purposes
| of the :class:`.Enum` datatype, this class need only provide a
| ``__members__`` method.
|
| When using an enumerated class, the enumerated objects are used
| both for input and output, rather than strings as is the case with
| a plain-string enumerated type::
|
| import enum
| from sqlalchemy import Enum
|
|
| class MyEnum(enum.Enum):
| one = 1
| two = 2
| three = 3
|
|
| t = Table("data", MetaData(), Column("value", Enum(MyEnum)))
|
| connection.execute(t.insert(), {"value": MyEnum.two})
| assert connection.scalar(t.select()) is MyEnum.two
|
| Above, the string names of each element, e.g. "one", "two", "three",
| are persisted to the database; the values of the Python Enum, here
| indicated as integers, are **not** used; the value of each enum can
| therefore be any kind of Python object whether or not it is persistable.
|
| In order to persist the values and not the names, the
| :paramref:`.Enum.values_callable` parameter may be used. The value of
| this parameter is a user-supplied callable, which is intended to be used
| with a PEP-435-compliant enumerated class and returns a list of string
| values to be persisted. For a simple enumeration that uses string values,
| a callable such as ``lambda x: [e.value for e in x]`` is sufficient.
|
| .. seealso::
|
| :ref:`orm_declarative_mapped_column_enums` - background on using
| the :class:`_sqltypes.Enum` datatype with the ORM's
| :ref:`ORM Annotated Declarative <orm_declarative_mapped_column>`
| feature.
|
| :class:`_postgresql.ENUM` - PostgreSQL-specific type,
| which has additional functionality.
|
| :class:`.mysql.ENUM` - MySQL-specific type
|
| Method resolution order:
| Enum
| String
| Concatenable
| SchemaType
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.type_api.Emulated
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, *enums: 'Union[str, Type[enum.Enum]]', **kw: 'Any') -> 'None'
| Construct an enum.
|
| Keyword arguments which don't apply to a specific backend are ignored
| by that backend.
|
| :param \*enums: either exactly one PEP-435 compliant enumerated type
| or one or more string labels.
|
| :param create_constraint: defaults to False. When creating a
| non-native enumerated type, also build a CHECK constraint on the
| database against the valid values.
|
| .. 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:`.Enum.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 metadata: Associate this type directly with a ``MetaData``
| object. For types that exist on the target database as an
| independent schema construct (PostgreSQL), this type will be
| created and dropped within ``create_all()`` and ``drop_all()``
| operations. If the type is not associated with any ``MetaData``
| object, it will associate itself with each ``Table`` in which it is
| used, and will be created when any of those individual tables are
| created, after a check is performed for its existence. The type is
| only dropped when ``drop_all()`` is called for that ``Table``
| object's metadata, however.
|
| The value of the :paramref:`_schema.MetaData.schema` parameter of
| the :class:`_schema.MetaData` object, if set, will be used as the
| default value of the :paramref:`_types.Enum.schema` on this object
| if an explicit value is not otherwise supplied.
|
| .. versionchanged:: 1.4.12 :class:`_types.Enum` inherits the
| :paramref:`_schema.MetaData.schema` parameter of the
| :class:`_schema.MetaData` object if present, when passed using
| the :paramref:`_types.Enum.metadata` parameter.
|
| :param name: The name of this type. This is required for PostgreSQL
| and any future supported database which requires an explicitly
| named type, or an explicitly named constraint in order to generate
| the type and/or a table that uses it. If a PEP-435 enumerated
| class was used, its name (converted to lower case) is used by
| default.
|
| :param native_enum: Use the database's native ENUM type when
| available. Defaults to True. When False, uses VARCHAR + check
| constraint for all backends. When False, the VARCHAR length can be
| controlled with :paramref:`.Enum.length`; currently "length" is
| ignored if native_enum=True.
|
| :param length: Allows specifying a custom length for the VARCHAR
| when a non-native enumeration datatype is used. By default it uses
| the length of the longest value.
|
| .. versionchanged:: 2.0.0 The :paramref:`.Enum.length` parameter
| is used unconditionally for ``VARCHAR`` rendering regardless of
| the :paramref:`.Enum.native_enum` parameter, for those backends
| where ``VARCHAR`` is used for enumerated datatypes.
|
|
| :param schema: Schema name of this type. For types that exist on the
| target database as an independent schema construct (PostgreSQL),
| this parameter specifies the named schema in which the type is
| present.
|
| If not present, the schema name will be taken from the
| :class:`_schema.MetaData` collection if passed as
| :paramref:`_types.Enum.metadata`, for a :class:`_schema.MetaData`
| that includes the :paramref:`_schema.MetaData.schema` parameter.
|
| .. versionchanged:: 1.4.12 :class:`_types.Enum` inherits the
| :paramref:`_schema.MetaData.schema` parameter of the
| :class:`_schema.MetaData` object if present, when passed using
| the :paramref:`_types.Enum.metadata` parameter.
|
| Otherwise, if the :paramref:`_types.Enum.inherit_schema` flag is set
| to ``True``, the schema will be inherited from the associated
| :class:`_schema.Table` object if any; when
| :paramref:`_types.Enum.inherit_schema` is at its default of
| ``False``, the owning table's schema is **not** used.
|
|
| :param quote: Set explicit quoting preferences for the type's name.
|
| :param inherit_schema: When ``True``, the "schema" from the owning
| :class:`_schema.Table`
| will be copied to the "schema" attribute of this
| :class:`.Enum`, replacing whatever value was passed for the
| ``schema`` attribute. This also takes effect when using the
| :meth:`_schema.Table.to_metadata` operation.
|
| :param validate_strings: when True, string values that are being
| passed to the database in a SQL statement will be checked
| for validity against the list of enumerated values. Unrecognized
| values will result in a ``LookupError`` being raised.
|
| :param values_callable: A callable which will be passed the PEP-435
| compliant enumerated type, which should then return a list of string
| values to be persisted. This allows for alternate usages such as
| using the string value of an enum to be persisted to the database
| instead of its name. The callable must return the values to be
| persisted in the same order as iterating through the Enum's
| ``__member__`` attribute. For example
| ``lambda x: [i.value for i in x]``.
|
| .. versionadded:: 1.2.3
|
| :param sort_key_function: a Python callable which may be used as the
| "key" argument in the Python ``sorted()`` built-in. The SQLAlchemy
| ORM requires that primary key columns which are mapped must
| be sortable in some way. When using an unsortable enumeration
| object such as a Python 3 ``Enum`` object, this parameter may be
| used to set a default sort key function for the objects. By
| default, the database value of the enumeration is used as the
| sorting function.
|
| .. versionadded:: 1.3.8
|
| :param omit_aliases: A boolean that when true will remove aliases from
| pep 435 enums. defaults to ``True``.
|
| .. versionchanged:: 2.0 This parameter now defaults to True.
|
| __repr__(self)
| Return repr(self).
|
| adapt(self, cls, **kw)
| 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.
|
| adapt_to_emulated(self, impltype, **kw)
| Given an impl class, adapt this type to the impl assuming
| "emulated".
|
| The impl should also be an "emulated" version of this type,
| most likely the same class as this type itself.
|
| e.g.: sqltypes.Enum adapts to the Enum class.
|
| as_generic(self, allow_nulltype=False)
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| copy(self, **kw)
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| native
|
| 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.
|
| sort_key_function
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Enum.Comparator'>
|
| __annotations__ = {'_object_lookup': 'Dict[Optional[str], Union[enum.E...
|
| __parameters__ = ()
|
| __visit_name__ = 'enum'
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Enum.Comparator'>
|
| ----------------------------------------------------------------------
| Methods inherited from String:
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Concatenable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaType:
|
| create(self, bind: '_CreateDropBind', checkfirst: 'bool' = False) -> 'None'
| Issue CREATE DDL for this type, if applicable.
|
| drop(self, bind: '_CreateDropBind', checkfirst: 'bool' = False) -> 'None'
| Issue DROP DDL for this type, if applicable.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __str__(self) -> 'str'
| Return str(self).
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.FLOAT
Python Library Documentation: class FLOAT in module sqlalchemy.sql.sqltypes
class FLOAT(Float)
| FLOAT(precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
|
| The SQL FLOAT type.
|
| .. seealso::
|
| :class:`_types.Float` - documentation for the base type.
|
| Method resolution order:
| FLOAT
| Float
| Numeric
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'FLOAT'
|
| ----------------------------------------------------------------------
| Methods inherited from Float:
|
| __init__(self: 'Float[_N]', precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
| Construct a Float.
|
| :param precision: the numeric precision for use in DDL ``CREATE
| TABLE``. Backends **should** attempt to ensure this precision
| indicates a number of digits for the generic
| :class:`_sqltypes.Float` datatype.
|
| .. note:: For the Oracle Database backend, the
| :paramref:`_sqltypes.Float.precision` parameter is not accepted
| when rendering DDL, as Oracle Database does not support float precision
| specified as a number of decimal places. Instead, use the
| Oracle Database-specific :class:`_oracle.FLOAT` datatype and specify the
| :paramref:`_oracle.FLOAT.binary_precision` parameter. This is new
| in version 2.0 of SQLAlchemy.
|
| To create a database agnostic :class:`_types.Float` that
| separately specifies binary precision for Oracle Database, use
| :meth:`_types.TypeEngine.with_variant` as follows::
|
| from sqlalchemy import Column
| from sqlalchemy import Float
| from sqlalchemy.dialects import oracle
|
| Column(
| "float_data",
| Float(5).with_variant(oracle.FLOAT(binary_precision=16), "oracle"),
| )
|
| :param asdecimal: the same flag as that of :class:`.Numeric`, but
| defaults to ``False``. Note that setting this flag to ``True``
| results in floating point conversion.
|
| :param decimal_return_scale: Default scale to use when converting
| from floats to Python decimals. Floating point values will typically
| be much longer due to decimal inaccuracy, and most floating point
| database types don't have a notion of "scale", so by default the
| float type looks for the first ten decimal places when converting.
| Specifying this value will override that length. Note that the
| MySQL float types, which do include "scale", will use "scale"
| as the default for decimal_return_scale, if not otherwise specified.
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Float:
|
| scale = None
|
| ----------------------------------------------------------------------
| Methods inherited from Numeric:
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Numeric:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.FetchedValue
Python Library Documentation: class FetchedValue in module sqlalchemy.sql.schema
class FetchedValue(sqlalchemy.sql.base.SchemaEventTarget)
| FetchedValue(for_update: 'bool' = False) -> 'None'
|
| A marker for a transparent database-side default.
|
| Use :class:`.FetchedValue` when the database is configured
| to provide some automatic default for a column.
|
| E.g.::
|
| Column("foo", Integer, FetchedValue())
|
| Would indicate that some trigger or default generator
| will create a new value for the ``foo`` column during an
| INSERT.
|
| .. seealso::
|
| :ref:`triggered_columns`
|
| Method resolution order:
| FetchedValue
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| builtins.object
|
| Methods defined here:
|
| __init__(self, for_update: 'bool' = False) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'column': 'Optional[Column[Any]]'}
|
| has_argument = False
|
| is_clause_element = False
|
| is_identity = False
|
| is_server_default = True
|
| reflected = False
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
sqlmodel.Field
Python Library Documentation: function Field in module sqlmodel.main Field(default: 'Any' = PydanticUndefined, *, default_factory: 'NoArgAnyCallable | None' = None, alias: 'str | None' = None, validation_alias: 'str | None' = None, serialization_alias: 'str | None' = None, title: 'str | None' = None, description: 'str | None' = None, exclude: 'Set[int | str] | Mapping[int | str, Any] | Any' = None, include: 'Set[int | str] | Mapping[int | str, Any] | Any' = None, const: 'bool | None' = None, gt: 'float | None' = None, ge: 'float | None' = None, lt: 'float | None' = None, le: 'float | None' = None, multiple_of: 'float | None' = None, max_digits: 'int | None' = None, decimal_places: 'int | None' = None, min_items: 'int | None' = None, max_items: 'int | None' = None, unique_items: 'bool | None' = None, min_length: 'int | None' = None, max_length: 'int | None' = None, allow_mutation: 'bool' = True, regex: 'str | None' = None, discriminator: 'str | None' = None, repr: 'bool' = True, primary_key: 'bool | UndefinedType' = PydanticUndefined, foreign_key: 'Any' = PydanticUndefined, ondelete: 'OnDeleteType | UndefinedType' = PydanticUndefined, unique: 'bool | UndefinedType' = PydanticUndefined, nullable: 'bool | UndefinedType' = PydanticUndefined, index: 'bool | UndefinedType' = PydanticUndefined, sa_type: 'type[Any] | UndefinedType' = PydanticUndefined, sa_column: 'Column | UndefinedType' = PydanticUndefined, sa_column_args: 'Sequence[Any] | UndefinedType' = PydanticUndefined, sa_column_kwargs: 'Mapping[str, Any] | UndefinedType' = PydanticUndefined, schema_extra: 'dict[str, Any] | None' = None) -> 'Any'
sqlmodel.Float
Python Library Documentation: class Float in module sqlalchemy.sql.sqltypes
class Float(Numeric)
| Float(precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
|
| Type representing floating point types, such as ``FLOAT`` or ``REAL``.
|
| This type returns Python ``float`` objects by default, unless the
| :paramref:`.Float.asdecimal` flag is set to ``True``, in which case they
| are coerced to ``decimal.Decimal`` objects.
|
| When a :paramref:`.Float.precision` is not provided in a
| :class:`_types.Float` type some backend may compile this type as
| an 8 bytes / 64 bit float datatype. To use a 4 bytes / 32 bit float
| datatype a precision <= 24 can usually be provided or the
| :class:`_types.REAL` type can be used.
| This is known to be the case in the PostgreSQL and MSSQL dialects
| that render the type as ``FLOAT`` that's in both an alias of
| ``DOUBLE PRECISION``. Other third party dialects may have similar
| behavior.
|
| Method resolution order:
| Float
| Numeric
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'Float[_N]', precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
| Construct a Float.
|
| :param precision: the numeric precision for use in DDL ``CREATE
| TABLE``. Backends **should** attempt to ensure this precision
| indicates a number of digits for the generic
| :class:`_sqltypes.Float` datatype.
|
| .. note:: For the Oracle Database backend, the
| :paramref:`_sqltypes.Float.precision` parameter is not accepted
| when rendering DDL, as Oracle Database does not support float precision
| specified as a number of decimal places. Instead, use the
| Oracle Database-specific :class:`_oracle.FLOAT` datatype and specify the
| :paramref:`_oracle.FLOAT.binary_precision` parameter. This is new
| in version 2.0 of SQLAlchemy.
|
| To create a database agnostic :class:`_types.Float` that
| separately specifies binary precision for Oracle Database, use
| :meth:`_types.TypeEngine.with_variant` as follows::
|
| from sqlalchemy import Column
| from sqlalchemy import Float
| from sqlalchemy.dialects import oracle
|
| Column(
| "float_data",
| Float(5).with_variant(oracle.FLOAT(binary_precision=16), "oracle"),
| )
|
| :param asdecimal: the same flag as that of :class:`.Numeric`, but
| defaults to ``False``. Note that setting this flag to ``True``
| results in floating point conversion.
|
| :param decimal_return_scale: Default scale to use when converting
| from floats to Python decimals. Floating point values will typically
| be much longer due to decimal inaccuracy, and most floating point
| database types don't have a notion of "scale", so by default the
| float type looks for the first ten decimal places when converting.
| Specifying this value will override that length. Note that the
| MySQL float types, which do include "scale", will use "scale"
| as the default for decimal_return_scale, if not otherwise specified.
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'float'
|
| scale = None
|
| ----------------------------------------------------------------------
| Methods inherited from Numeric:
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Numeric:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.ForeignKey
Python Library Documentation: class ForeignKey in module sqlalchemy.sql.schema
class ForeignKey(sqlalchemy.sql.base.DialectKWArgs, SchemaItem)
| ForeignKey(column: '_DDLColumnArgument', _constraint: 'Optional[ForeignKeyConstraint]' = None, use_alter: 'bool' = False, name: '_ConstraintNameArgument' = None, onupdate: 'Optional[str]' = None, ondelete: 'Optional[str]' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, link_to_name: 'bool' = False, match: 'Optional[str]' = None, info: 'Optional[_InfoType]' = None, comment: 'Optional[str]' = None, _unresolvable: 'bool' = False, **dialect_kw: 'Any')
|
| Defines a dependency between two columns.
|
| ``ForeignKey`` is specified as an argument to a :class:`_schema.Column`
| object,
| e.g.::
|
| t = Table(
| "remote_table",
| metadata,
| Column("remote_id", ForeignKey("main_table.id")),
| )
|
| Note that ``ForeignKey`` is only a marker object that defines
| a dependency between two columns. The actual constraint
| is in all cases represented by the :class:`_schema.ForeignKeyConstraint`
| object. This object will be generated automatically when
| a ``ForeignKey`` is associated with a :class:`_schema.Column` which
| in turn is associated with a :class:`_schema.Table`. Conversely,
| when :class:`_schema.ForeignKeyConstraint` is applied to a
| :class:`_schema.Table`,
| ``ForeignKey`` markers are automatically generated to be
| present on each associated :class:`_schema.Column`, which are also
| associated with the constraint object.
|
| Note that you cannot define a "composite" foreign key constraint,
| that is a constraint between a grouping of multiple parent/child
| columns, using ``ForeignKey`` objects. To define this grouping,
| the :class:`_schema.ForeignKeyConstraint` object must be used, and applied
| to the :class:`_schema.Table`. The associated ``ForeignKey`` objects
| are created automatically.
|
| The ``ForeignKey`` objects associated with an individual
| :class:`_schema.Column`
| object are available in the `foreign_keys` collection
| of that column.
|
| Further examples of foreign key configuration are in
| :ref:`metadata_foreignkeys`.
|
| Method resolution order:
| ForeignKey
| sqlalchemy.sql.base.DialectKWArgs
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __init__(self, column: '_DDLColumnArgument', _constraint: 'Optional[ForeignKeyConstraint]' = None, use_alter: 'bool' = False, name: '_ConstraintNameArgument' = None, onupdate: 'Optional[str]' = None, ondelete: 'Optional[str]' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, link_to_name: 'bool' = False, match: 'Optional[str]' = None, info: 'Optional[_InfoType]' = None, comment: 'Optional[str]' = None, _unresolvable: 'bool' = False, **dialect_kw: 'Any')
| Construct a column-level FOREIGN KEY.
|
| The :class:`_schema.ForeignKey` object when constructed generates a
| :class:`_schema.ForeignKeyConstraint`
| which is associated with the parent
| :class:`_schema.Table` object's collection of constraints.
|
| :param column: A single target column for the key relationship. A
| :class:`_schema.Column` object or a column name as a string:
| ``tablename.columnkey`` or ``schema.tablename.columnkey``.
| ``columnkey`` is the ``key`` which has been assigned to the column
| (defaults to the column name itself), unless ``link_to_name`` is
| ``True`` in which case the rendered name of the column is used.
|
| :param name: Optional string. An in-database name for the key if
| `constraint` is not provided.
|
| :param onupdate: Optional string. If set, emit ON UPDATE <value> when
| issuing DDL for this constraint. Typical values include CASCADE,
| DELETE and RESTRICT.
|
| .. seealso::
|
| :ref:`on_update_on_delete`
|
| :param ondelete: Optional string. If set, emit ON DELETE <value> when
| issuing DDL for this constraint. Typical values include CASCADE,
| SET NULL and RESTRICT. Some dialects may allow for additional
| syntaxes.
|
| .. seealso::
|
| :ref:`on_update_on_delete`
|
| :param deferrable: Optional bool. If set, emit DEFERRABLE or NOT
| DEFERRABLE when issuing DDL for this constraint.
|
| :param initially: Optional string. If set, emit INITIALLY <value> when
| issuing DDL for this constraint.
|
| :param link_to_name: if True, the string name given in ``column`` is
| the rendered name of the referenced column, not its locally
| assigned ``key``.
|
| :param use_alter: passed to the underlying
| :class:`_schema.ForeignKeyConstraint`
| to indicate the constraint should
| be generated/dropped externally from the CREATE TABLE/ DROP TABLE
| statement. See :paramref:`_schema.ForeignKeyConstraint.use_alter`
| for further description.
|
| .. seealso::
|
| :paramref:`_schema.ForeignKeyConstraint.use_alter`
|
| :ref:`use_alter`
|
| :param match: Optional string. If set, emit MATCH <value> when issuing
| DDL for this constraint. Typical values include SIMPLE, PARTIAL
| and FULL.
|
| :param info: Optional data dictionary which will be populated into the
| :attr:`.SchemaItem.info` attribute of this object.
|
| :param comment: Optional string that will render an SQL comment on
| foreign key constraint creation.
|
| .. versionadded:: 2.0
|
| :param \**dialect_kw: Additional keyword arguments are dialect
| specific, and passed in the form ``<dialectname>_<argname>``. The
| arguments are ultimately handled by a corresponding
| :class:`_schema.ForeignKeyConstraint`.
| See the documentation regarding
| an individual dialect at :ref:`dialect_toplevel` for detail on
| documented arguments.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| column(...)
| Return the target :class:`_schema.Column` referenced by this
| :class:`_schema.ForeignKey`.
|
| If no target column has been established, an exception
| is raised.
|
| copy(self, *, schema: 'Optional[str]' = None, **kw: 'Any') -> 'ForeignKey'
| .. deprecated:: 1.4 The :meth:`_schema.ForeignKey.copy` method is deprecated and will be removed in a future release.
|
| get_referent(self, table: 'FromClause') -> 'Optional[Column[Any]]'
| Return the :class:`_schema.Column` in the given
| :class:`_schema.Table` (or any :class:`.FromClause`)
| referenced by this :class:`_schema.ForeignKey`.
|
| Returns None if this :class:`_schema.ForeignKey`
| does not reference the given
| :class:`_schema.Table`.
|
| references(self, table: 'Table') -> 'bool'
| Return True if the given :class:`_schema.Table`
| is referenced by this
| :class:`_schema.ForeignKey`.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| target_fullname
| Return a string based 'column specification' for this
| :class:`_schema.ForeignKey`.
|
| This is usually the equivalent of the string-based "tablename.colname"
| argument first passed to the object's constructor.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'_table_column': 'Optional[Column[Any]]', 'parent':...
|
| __visit_name__ = 'foreign_key'
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_options(...)
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| This is a two-level nested registry, keyed to ``<dialect_name>``
| and ``<argument_name>``. For example, the ``postgresql_where``
| argument would be locatable as::
|
| arg = my_object.dialect_options["postgresql"]["where"]
|
| .. versionadded:: 0.9.2
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form
|
| get_dialect_option(self, dialect: 'Dialect', argument_name: 'str', *, else_: 'Any' = None, deprecated_fallback: 'Optional[str]' = None) -> 'Any'
| Return the value of a dialect-specific option, or *else_* if
| this dialect does not register the given argument.
|
| This is useful for DDL compilers that may be inherited by
| third-party dialects whose ``construct_arguments`` do not
| include the same set of keys as the parent dialect.
|
| :param dialect: The dialect for which to retrieve the option.
| :param argument_name: The name of the argument to retrieve.
| :param else\_: The value to return if the argument is not present.
| :param deprecated_fallback: Optional dialect name to fall back to
| if the argument is not present for the current dialect. If the
| argument is present for the fallback dialect but not the current
| dialect, a deprecation warning will be emitted.
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| argument_for(dialect_name: 'str', argument_name: 'str', default: 'Any') -> 'None'
| Add a new kind of dialect-specific keyword argument for this class.
|
| E.g.::
|
| Index.argument_for("mydialect", "length", None)
|
| some_index = Index("a", "b", mydialect_length=5)
|
| The :meth:`.DialectKWArgs.argument_for` method is a per-argument
| way adding extra arguments to the
| :attr:`.DefaultDialect.construct_arguments` dictionary. This
| dictionary provides a list of argument names accepted by various
| schema-level constructs on behalf of a dialect.
|
| New dialects should typically specify this dictionary all at once as a
| data member of the dialect class. The use case for ad-hoc addition of
| argument names is typically for end-user code that is also using
| a custom compilation scheme which consumes the additional arguments.
|
| :param dialect_name: name of a dialect. The dialect must be
| locatable, else a :class:`.NoSuchModuleError` is raised. The
| dialect must also include an existing
| :attr:`.DefaultDialect.construct_arguments` collection, indicating
| that it participates in the keyword-argument validation and default
| system, else :class:`.ArgumentError` is raised. If the dialect does
| not include this collection, then any keyword argument can be
| specified on behalf of this dialect already. All dialects packaged
| within SQLAlchemy include this collection, however for third party
| dialects, support may vary.
|
| :param argument_name: name of the parameter.
|
| :param default: default value of the parameter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_kwargs
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| The arguments are present here in their original ``<dialect>_<kwarg>``
| format. Only arguments that were actually passed are included;
| unlike the :attr:`.DialectKWArgs.dialect_options` collection, which
| contains all options known by this dialect including defaults.
|
| The collection is also writable; keys are accepted of the
| form ``<dialect>_<kwarg>`` where the value will be assembled
| into the list of options.
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_options` - nested dictionary form
|
| kwargs
| A synonym for :attr:`.DialectKWArgs.dialect_kwargs`.
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.ForeignKeyConstraint
Python Library Documentation: class ForeignKeyConstraint in module sqlalchemy.sql.schema
class ForeignKeyConstraint(ColumnCollectionConstraint)
| ForeignKeyConstraint(columns: '_typing_Sequence[_DDLColumnArgument]', refcolumns: '_typing_Sequence[_DDLColumnArgument]', name: '_ConstraintNameArgument' = None, onupdate: 'Optional[str]' = None, ondelete: 'Optional[str]' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, use_alter: 'bool' = False, link_to_name: 'bool' = False, match: 'Optional[str]' = None, table: 'Optional[Table]' = None, info: 'Optional[_InfoType]' = None, comment: 'Optional[str]' = None, **dialect_kw: 'Any') -> 'None'
|
| A table-level FOREIGN KEY constraint.
|
| Defines a single column or composite FOREIGN KEY ... REFERENCES
| constraint. For a no-frills, single column foreign key, adding a
| :class:`_schema.ForeignKey` to the definition of a :class:`_schema.Column`
| is a
| shorthand equivalent for an unnamed, single column
| :class:`_schema.ForeignKeyConstraint`.
|
| Examples of foreign key configuration are in :ref:`metadata_foreignkeys`.
|
| Method resolution order:
| ForeignKeyConstraint
| ColumnCollectionConstraint
| ColumnCollectionMixin
| Constraint
| sqlalchemy.sql.base.DialectKWArgs
| HasConditionalDDL
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __init__(self, columns: '_typing_Sequence[_DDLColumnArgument]', refcolumns: '_typing_Sequence[_DDLColumnArgument]', name: '_ConstraintNameArgument' = None, onupdate: 'Optional[str]' = None, ondelete: 'Optional[str]' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, use_alter: 'bool' = False, link_to_name: 'bool' = False, match: 'Optional[str]' = None, table: 'Optional[Table]' = None, info: 'Optional[_InfoType]' = None, comment: 'Optional[str]' = None, **dialect_kw: 'Any') -> 'None'
| Construct a composite-capable FOREIGN KEY.
|
| :param columns: A sequence of local column names. The named columns
| must be defined and present in the parent Table. The names should
| match the ``key`` given to each column (defaults to the name) unless
| ``link_to_name`` is True.
|
| :param refcolumns: A sequence of foreign column names or Column
| objects. The columns must all be located within the same Table.
|
| :param name: Optional, the in-database name of the key.
|
| :param onupdate: Optional string. If set, emit ON UPDATE <value> when
| issuing DDL for this constraint. Typical values include CASCADE,
| DELETE and RESTRICT.
|
| .. seealso::
|
| :ref:`on_update_on_delete`
|
| :param ondelete: Optional string. If set, emit ON DELETE <value> when
| issuing DDL for this constraint. Typical values include CASCADE,
| SET NULL and RESTRICT. Some dialects may allow for additional
| syntaxes.
|
| .. seealso::
|
| :ref:`on_update_on_delete`
|
| :param deferrable: Optional bool. If set, emit DEFERRABLE or NOT
| DEFERRABLE when issuing DDL for this constraint.
|
| :param initially: Optional string. If set, emit INITIALLY <value> when
| issuing DDL for this constraint.
|
| :param link_to_name: if True, the string name given in ``column`` is
| the rendered name of the referenced column, not its locally assigned
| ``key``.
|
| :param use_alter: If True, do not emit the DDL for this constraint as
| part of the CREATE TABLE definition. Instead, generate it via an
| ALTER TABLE statement issued after the full collection of tables
| have been created, and drop it via an ALTER TABLE statement before
| the full collection of tables are dropped.
|
| The use of :paramref:`_schema.ForeignKeyConstraint.use_alter` is
| particularly geared towards the case where two or more tables
| are established within a mutually-dependent foreign key constraint
| relationship; however, the :meth:`_schema.MetaData.create_all` and
| :meth:`_schema.MetaData.drop_all`
| methods will perform this resolution
| automatically, so the flag is normally not needed.
|
| .. seealso::
|
| :ref:`use_alter`
|
| :param match: Optional string. If set, emit MATCH <value> when issuing
| DDL for this constraint. Typical values include SIMPLE, PARTIAL
| and FULL.
|
| :param info: Optional data dictionary which will be populated into the
| :attr:`.SchemaItem.info` attribute of this object.
|
| :param comment: Optional string that will render an SQL comment on
| foreign key constraint creation.
|
| .. versionadded:: 2.0
|
| :param \**dialect_kw: Additional keyword arguments are dialect
| specific, and passed in the form ``<dialectname>_<argname>``. See
| the documentation regarding an individual dialect at
| :ref:`dialect_toplevel` for detail on documented arguments.
|
| copy(self, *, schema: 'Optional[str]' = None, target_table: 'Optional[Table]' = None, **kw: 'Any') -> 'ForeignKeyConstraint'
| .. deprecated:: 1.4 The :meth:`_schema.ForeignKeyConstraint.copy` method is deprecated and will be removed in a future release.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| column_keys
| Return a list of string keys representing the local
| columns in this :class:`_schema.ForeignKeyConstraint`.
|
| This list is either the original string arguments sent
| to the constructor of the :class:`_schema.ForeignKeyConstraint`,
| or if the constraint has been initialized with :class:`_schema.Column`
| objects, is the string ``.key`` of each element.
|
| referred_table
| The :class:`_schema.Table` object to which this
| :class:`_schema.ForeignKeyConstraint` references.
|
| This is a dynamically calculated attribute which may not be available
| if the constraint and/or parent table is not yet associated with
| a metadata collection that contains the referred table.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'columns': 'ReadOnlyColumnCollection[str, Column[An...
|
| __visit_name__ = 'foreign_key_constraint'
|
| ----------------------------------------------------------------------
| Methods inherited from ColumnCollectionConstraint:
|
| __contains__(self, x: 'Any') -> 'bool'
|
| __iter__(self) -> 'Iterator[Column[Any]]'
|
| __len__(self) -> 'int'
|
| contains_column(self, col: 'Column[Any]') -> 'bool'
| Return True if this constraint contains the given column.
|
| Note that this object also contains an attribute ``.columns``
| which is a :class:`_expression.ColumnCollection` of
| :class:`_schema.Column` objects.
|
| ----------------------------------------------------------------------
| Methods inherited from ColumnCollectionMixin:
|
| c(...)
|
| columns(...)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ColumnCollectionMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Constraint:
|
| table
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_options(...)
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| This is a two-level nested registry, keyed to ``<dialect_name>``
| and ``<argument_name>``. For example, the ``postgresql_where``
| argument would be locatable as::
|
| arg = my_object.dialect_options["postgresql"]["where"]
|
| .. versionadded:: 0.9.2
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form
|
| get_dialect_option(self, dialect: 'Dialect', argument_name: 'str', *, else_: 'Any' = None, deprecated_fallback: 'Optional[str]' = None) -> 'Any'
| Return the value of a dialect-specific option, or *else_* if
| this dialect does not register the given argument.
|
| This is useful for DDL compilers that may be inherited by
| third-party dialects whose ``construct_arguments`` do not
| include the same set of keys as the parent dialect.
|
| :param dialect: The dialect for which to retrieve the option.
| :param argument_name: The name of the argument to retrieve.
| :param else\_: The value to return if the argument is not present.
| :param deprecated_fallback: Optional dialect name to fall back to
| if the argument is not present for the current dialect. If the
| argument is present for the fallback dialect but not the current
| dialect, a deprecation warning will be emitted.
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| argument_for(dialect_name: 'str', argument_name: 'str', default: 'Any') -> 'None'
| Add a new kind of dialect-specific keyword argument for this class.
|
| E.g.::
|
| Index.argument_for("mydialect", "length", None)
|
| some_index = Index("a", "b", mydialect_length=5)
|
| The :meth:`.DialectKWArgs.argument_for` method is a per-argument
| way adding extra arguments to the
| :attr:`.DefaultDialect.construct_arguments` dictionary. This
| dictionary provides a list of argument names accepted by various
| schema-level constructs on behalf of a dialect.
|
| New dialects should typically specify this dictionary all at once as a
| data member of the dialect class. The use case for ad-hoc addition of
| argument names is typically for end-user code that is also using
| a custom compilation scheme which consumes the additional arguments.
|
| :param dialect_name: name of a dialect. The dialect must be
| locatable, else a :class:`.NoSuchModuleError` is raised. The
| dialect must also include an existing
| :attr:`.DefaultDialect.construct_arguments` collection, indicating
| that it participates in the keyword-argument validation and default
| system, else :class:`.ArgumentError` is raised. If the dialect does
| not include this collection, then any keyword argument can be
| specified on behalf of this dialect already. All dialects packaged
| within SQLAlchemy include this collection, however for third party
| dialects, support may vary.
|
| :param argument_name: name of the parameter.
|
| :param default: default value of the parameter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_kwargs
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| The arguments are present here in their original ``<dialect>_<kwarg>``
| format. Only arguments that were actually passed are included;
| unlike the :attr:`.DialectKWArgs.dialect_options` collection, which
| contains all options known by this dialect including defaults.
|
| The collection is also writable; keys are accepted of the
| form ``<dialect>_<kwarg>`` where the value will be assembled
| into the list of options.
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_options` - nested dictionary form
|
| kwargs
| A synonym for :attr:`.DialectKWArgs.dialect_kwargs`.
|
| ----------------------------------------------------------------------
| Methods inherited from HasConditionalDDL:
|
| ddl_if(self, dialect: 'Optional[str]' = None, callable_: 'Optional[ddl.DDLIfCallable]' = None, state: 'Optional[Any]' = None) -> 'Self'
| apply a conditional DDL rule to this schema item.
|
| These rules work in a similar manner to the
| :meth:`.ExecutableDDLElement.execute_if` callable, with the added
| feature that the criteria may be checked within the DDL compilation
| phase for a construct such as :class:`.CreateTable`.
| :meth:`.HasConditionalDDL.ddl_if` currently applies towards the
| :class:`.Index` construct as well as all :class:`.Constraint`
| constructs.
|
| :param dialect: string name of a dialect, or a tuple of string names
| to indicate multiple dialect types.
|
| :param callable\_: a callable that is constructed using the same form
| as that described in
| :paramref:`.ExecutableDDLElement.execute_if.callable_`.
|
| :param state: any arbitrary object that will be passed to the
| callable, if present.
|
| .. versionadded:: 2.0
|
| .. seealso::
|
| :ref:`schema_ddl_ddl_if` - background and usage examples
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.INT
Python Library Documentation: class INTEGER in module sqlalchemy.sql.sqltypes
class INTEGER(Integer)
| The SQL INT or INTEGER type.
|
| .. seealso::
|
| :class:`_types.Integer` - documentation for the base type.
|
| Method resolution order:
| INTEGER
| Integer
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'INTEGER'
|
| ----------------------------------------------------------------------
| Methods inherited from Integer:
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Integer:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.INTEGER
Python Library Documentation: class INTEGER in module sqlalchemy.sql.sqltypes
class INTEGER(Integer)
| The SQL INT or INTEGER type.
|
| .. seealso::
|
| :class:`_types.Integer` - documentation for the base type.
|
| Method resolution order:
| INTEGER
| Integer
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'INTEGER'
|
| ----------------------------------------------------------------------
| Methods inherited from Integer:
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Integer:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Identity
Python Library Documentation: class Identity in module sqlalchemy.sql.schema
class Identity(IdentityOptions, FetchedValue, SchemaItem)
| Identity(always: 'bool' = False, on_null: 'Optional[bool]' = None, start: 'Optional[int]' = None, increment: 'Optional[int]' = None, minvalue: 'Optional[int]' = None, maxvalue: 'Optional[int]' = None, nominvalue: 'Optional[bool]' = None, nomaxvalue: 'Optional[bool]' = None, cycle: 'Optional[bool]' = None, cache: 'Optional[int]' = None, order: 'Optional[bool]' = None) -> 'None'
|
| Defines an identity column, i.e. "GENERATED { ALWAYS | BY DEFAULT }
| AS IDENTITY" syntax.
|
| The :class:`.Identity` construct is an inline construct added to the
| argument list of a :class:`_schema.Column` object::
|
| from sqlalchemy import Identity
|
| Table(
| "foo",
| metadata_obj,
| Column("id", Integer, Identity()),
| Column("description", Text),
| )
|
| See the linked documentation below for complete details.
|
| .. versionadded:: 1.4
|
| .. seealso::
|
| :ref:`identity_ddl`
|
| Method resolution order:
| Identity
| IdentityOptions
| FetchedValue
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __init__(self, always: 'bool' = False, on_null: 'Optional[bool]' = None, start: 'Optional[int]' = None, increment: 'Optional[int]' = None, minvalue: 'Optional[int]' = None, maxvalue: 'Optional[int]' = None, nominvalue: 'Optional[bool]' = None, nomaxvalue: 'Optional[bool]' = None, cycle: 'Optional[bool]' = None, cache: 'Optional[int]' = None, order: 'Optional[bool]' = None) -> 'None'
| Construct a GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY DDL
| construct to accompany a :class:`_schema.Column`.
|
| See the :class:`.Sequence` documentation for a complete description
| of most parameters.
|
| .. note::
| MSSQL supports this construct as the preferred alternative to
| generate an IDENTITY on a column, but it uses non standard
| syntax that only support :paramref:`_schema.Identity.start`
| and :paramref:`_schema.Identity.increment`.
| All other parameters are ignored.
|
| :param always:
| A boolean, that indicates the type of identity column.
| If ``False`` is specified, the default, then the user-specified
| value takes precedence.
| If ``True`` is specified, a user-specified value is not accepted (
| on some backends, like PostgreSQL, OVERRIDING SYSTEM VALUE, or
| similar, may be specified in an INSERT to override the sequence
| value).
| Some backends also have a default value for this parameter,
| ``None`` can be used to omit rendering this part in the DDL. It
| will be treated as ``False`` if a backend does not have a default
| value.
|
| :param on_null:
| Set to ``True`` to specify ON NULL in conjunction with a
| ``always=False`` identity column. This option is only supported on
| some backends, like Oracle Database.
|
| :param start: the starting index of the sequence.
| :param increment: the increment value of the sequence.
| :param minvalue: the minimum value of the sequence.
| :param maxvalue: the maximum value of the sequence.
| :param nominvalue: no minimum value of the sequence.
| :param nomaxvalue: no maximum value of the sequence.
| :param cycle: allows the sequence to wrap around when the maxvalue
| or minvalue has been reached.
| :param cache: optional integer value; number of future values in the
| sequence which are calculated in advance.
| :param order: optional boolean value; if true, renders the
| ORDER keyword.
|
| copy(self, **kw: 'Any') -> 'Identity'
| .. deprecated:: 1.4 The :meth:`_schema.Identity.copy` method is deprecated and will be removed in a future release.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __visit_name__ = 'identity_column'
|
| is_identity = True
|
| ----------------------------------------------------------------------
| Data descriptors inherited from IdentityOptions:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from FetchedValue:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from FetchedValue:
|
| has_argument = False
|
| is_clause_element = False
|
| is_server_default = True
|
| reflected = False
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Index
Python Library Documentation: class Index in module sqlalchemy.sql.schema
class Index(sqlalchemy.sql.base.DialectKWArgs, ColumnCollectionMixin, HasConditionalDDL, SchemaItem)
| Index(name: 'Optional[str]', *expressions: '_DDLColumnArgument', unique: 'bool' = False, quote: 'Optional[bool]' = None, info: 'Optional[_InfoType]' = None, _table: 'Optional[Table]' = None, _column_flag: 'bool' = False, **dialect_kw: 'Any') -> 'None'
|
| A table-level INDEX.
|
| Defines a composite (one or more column) INDEX.
|
| E.g.::
|
| sometable = Table(
| "sometable",
| metadata,
| Column("name", String(50)),
| Column("address", String(100)),
| )
|
| Index("some_index", sometable.c.name)
|
| For a no-frills, single column index, adding
| :class:`_schema.Column` also supports ``index=True``::
|
| sometable = Table(
| "sometable", metadata, Column("name", String(50), index=True)
| )
|
| For a composite index, multiple columns can be specified::
|
| Index("some_index", sometable.c.name, sometable.c.address)
|
| Functional indexes are supported as well, typically by using the
| :data:`.func` construct in conjunction with table-bound
| :class:`_schema.Column` objects::
|
| Index("some_index", func.lower(sometable.c.name))
|
| An :class:`.Index` can also be manually associated with a
| :class:`_schema.Table`,
| either through inline declaration or using
| :meth:`_schema.Table.append_constraint`. When this approach is used,
| the names
| of the indexed columns can be specified as strings::
|
| Table(
| "sometable",
| metadata,
| Column("name", String(50)),
| Column("address", String(100)),
| Index("some_index", "name", "address"),
| )
|
| To support functional or expression-based indexes in this form, the
| :func:`_expression.text` construct may be used::
|
| from sqlalchemy import text
|
| Table(
| "sometable",
| metadata,
| Column("name", String(50)),
| Column("address", String(100)),
| Index("some_index", text("lower(name)")),
| )
|
| .. seealso::
|
| :ref:`schema_indexes` - General information on :class:`.Index`.
|
| :ref:`postgresql_indexes` - PostgreSQL-specific options available for
| the :class:`.Index` construct.
|
| :ref:`mysql_indexes` - MySQL-specific options available for the
| :class:`.Index` construct.
|
| :ref:`mssql_indexes` - MSSQL-specific options available for the
| :class:`.Index` construct.
|
| Method resolution order:
| Index
| sqlalchemy.sql.base.DialectKWArgs
| ColumnCollectionMixin
| HasConditionalDDL
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __init__(self, name: 'Optional[str]', *expressions: '_DDLColumnArgument', unique: 'bool' = False, quote: 'Optional[bool]' = None, info: 'Optional[_InfoType]' = None, _table: 'Optional[Table]' = None, _column_flag: 'bool' = False, **dialect_kw: 'Any') -> 'None'
| Construct an index object.
|
| :param name:
| The name of the index
|
| :param \*expressions:
| Column expressions to include in the index. The expressions
| are normally instances of :class:`_schema.Column`, but may also
| be arbitrary SQL expressions which ultimately refer to a
| :class:`_schema.Column`.
|
| :param unique=False:
| Keyword only argument; if True, create a unique index.
|
| :param quote=None:
| Keyword only argument; whether to apply quoting to the name of
| the index. Works in the same manner as that of
| :paramref:`_schema.Column.quote`.
|
| :param info=None: Optional data dictionary which will be populated
| into the :attr:`.SchemaItem.info` attribute of this object.
|
| :param \**dialect_kw: Additional keyword arguments not mentioned above
| are dialect specific, and passed in the form
| ``<dialectname>_<argname>``. See the documentation regarding an
| individual dialect at :ref:`dialect_toplevel` for detail on
| documented arguments.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| create(self, bind: '_CreateDropBind', checkfirst: 'bool' = False) -> 'None'
| Issue a ``CREATE`` statement for this
| :class:`.Index`, using the given
| :class:`.Connection` or :class:`.Engine`` for connectivity.
|
| .. seealso::
|
| :meth:`_schema.MetaData.create_all`.
|
| drop(self, bind: '_CreateDropBind', checkfirst: 'bool' = False) -> 'None'
| Issue a ``DROP`` statement for this
| :class:`.Index`, using the given
| :class:`.Connection` or :class:`.Engine` for connectivity.
|
| .. seealso::
|
| :meth:`_schema.MetaData.drop_all`.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'_table_bound_expressions': '_typing_Sequence[Colum...
|
| __visit_name__ = 'index'
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_options(...)
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| This is a two-level nested registry, keyed to ``<dialect_name>``
| and ``<argument_name>``. For example, the ``postgresql_where``
| argument would be locatable as::
|
| arg = my_object.dialect_options["postgresql"]["where"]
|
| .. versionadded:: 0.9.2
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form
|
| get_dialect_option(self, dialect: 'Dialect', argument_name: 'str', *, else_: 'Any' = None, deprecated_fallback: 'Optional[str]' = None) -> 'Any'
| Return the value of a dialect-specific option, or *else_* if
| this dialect does not register the given argument.
|
| This is useful for DDL compilers that may be inherited by
| third-party dialects whose ``construct_arguments`` do not
| include the same set of keys as the parent dialect.
|
| :param dialect: The dialect for which to retrieve the option.
| :param argument_name: The name of the argument to retrieve.
| :param else\_: The value to return if the argument is not present.
| :param deprecated_fallback: Optional dialect name to fall back to
| if the argument is not present for the current dialect. If the
| argument is present for the fallback dialect but not the current
| dialect, a deprecation warning will be emitted.
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| argument_for(dialect_name: 'str', argument_name: 'str', default: 'Any') -> 'None'
| Add a new kind of dialect-specific keyword argument for this class.
|
| E.g.::
|
| Index.argument_for("mydialect", "length", None)
|
| some_index = Index("a", "b", mydialect_length=5)
|
| The :meth:`.DialectKWArgs.argument_for` method is a per-argument
| way adding extra arguments to the
| :attr:`.DefaultDialect.construct_arguments` dictionary. This
| dictionary provides a list of argument names accepted by various
| schema-level constructs on behalf of a dialect.
|
| New dialects should typically specify this dictionary all at once as a
| data member of the dialect class. The use case for ad-hoc addition of
| argument names is typically for end-user code that is also using
| a custom compilation scheme which consumes the additional arguments.
|
| :param dialect_name: name of a dialect. The dialect must be
| locatable, else a :class:`.NoSuchModuleError` is raised. The
| dialect must also include an existing
| :attr:`.DefaultDialect.construct_arguments` collection, indicating
| that it participates in the keyword-argument validation and default
| system, else :class:`.ArgumentError` is raised. If the dialect does
| not include this collection, then any keyword argument can be
| specified on behalf of this dialect already. All dialects packaged
| within SQLAlchemy include this collection, however for third party
| dialects, support may vary.
|
| :param argument_name: name of the parameter.
|
| :param default: default value of the parameter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_kwargs
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| The arguments are present here in their original ``<dialect>_<kwarg>``
| format. Only arguments that were actually passed are included;
| unlike the :attr:`.DialectKWArgs.dialect_options` collection, which
| contains all options known by this dialect including defaults.
|
| The collection is also writable; keys are accepted of the
| form ``<dialect>_<kwarg>`` where the value will be assembled
| into the list of options.
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_options` - nested dictionary form
|
| kwargs
| A synonym for :attr:`.DialectKWArgs.dialect_kwargs`.
|
| ----------------------------------------------------------------------
| Methods inherited from ColumnCollectionMixin:
|
| c(...)
|
| columns(...)
|
| ----------------------------------------------------------------------
| Methods inherited from HasConditionalDDL:
|
| ddl_if(self, dialect: 'Optional[str]' = None, callable_: 'Optional[ddl.DDLIfCallable]' = None, state: 'Optional[Any]' = None) -> 'Self'
| apply a conditional DDL rule to this schema item.
|
| These rules work in a similar manner to the
| :meth:`.ExecutableDDLElement.execute_if` callable, with the added
| feature that the criteria may be checked within the DDL compilation
| phase for a construct such as :class:`.CreateTable`.
| :meth:`.HasConditionalDDL.ddl_if` currently applies towards the
| :class:`.Index` construct as well as all :class:`.Constraint`
| constructs.
|
| :param dialect: string name of a dialect, or a tuple of string names
| to indicate multiple dialect types.
|
| :param callable\_: a callable that is constructed using the same form
| as that described in
| :paramref:`.ExecutableDDLElement.execute_if.callable_`.
|
| :param state: any arbitrary object that will be passed to the
| callable, if present.
|
| .. versionadded:: 2.0
|
| .. seealso::
|
| :ref:`schema_ddl_ddl_if` - background and usage examples
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Integer
Python Library Documentation: class Integer in module sqlalchemy.sql.sqltypes
class Integer(HasExpressionLookup, sqlalchemy.sql.type_api.TypeEngine)
| A type for ``int`` integers.
|
| Method resolution order:
| Integer
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'integer'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Interval
Python Library Documentation: class Interval in module sqlalchemy.sql.sqltypes
class Interval(sqlalchemy.sql.type_api.Emulated, _AbstractInterval, sqlalchemy.sql.type_api.TypeDecorator)
| Interval(native: 'bool' = True, second_precision: 'Optional[int]' = None, day_precision: 'Optional[int]' = None)
|
| A type for ``datetime.timedelta()`` objects.
|
| The Interval type deals with ``datetime.timedelta`` objects. In PostgreSQL
| and Oracle Database, the native ``INTERVAL`` type is used; for others, the
| value is stored as a date which is relative to the "epoch" (Jan. 1, 1970).
|
| Note that the ``Interval`` type does not currently provide date arithmetic
| operations on platforms which do not support interval types natively. Such
| operations usually require transformation of both sides of the expression
| (such as, conversion of both sides into integer epoch values first) which
| currently is a manual procedure (such as via
| :attr:`~sqlalchemy.sql.expression.func`).
|
| Method resolution order:
| Interval
| sqlalchemy.sql.type_api.Emulated
| _AbstractInterval
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeDecorator
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.type_api.ExternalType
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, native: 'bool' = True, second_precision: 'Optional[int]' = None, day_precision: 'Optional[int]' = None)
| Construct an Interval object.
|
| :param native: when True, use the actual
| INTERVAL type provided by the database, if
| supported (currently PostgreSQL, Oracle Database).
| Otherwise, represent the interval data as
| an epoch value regardless.
|
| :param second_precision: For native interval types
| which support a "fractional seconds precision" parameter,
| i.e. Oracle Database and PostgreSQL
|
| :param day_precision: for native interval types which
| support a "day precision" parameter, i.e. Oracle Database.
|
| adapt_to_emulated(self, impltype, **kw)
| Given an impl class, adapt this type to the impl assuming
| "emulated".
|
| The impl should also be an "emulated" version of this type,
| most likely the same class as this type itself.
|
| e.g.: sqltypes.Enum adapts to the Enum class.
|
| bind_processor(self, dialect: 'Dialect') -> '_BindProcessorType[dt.timedelta]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op, value)
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| result_processor(self, dialect: 'Dialect', coltype: 'Any') -> '_ResultProcessorType[dt.timedelta]'
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Interval.Comparator'>
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| cache_ok = True
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Interval.Comparat...
|
| epoch = datetime.datetime(1970, 1, 1, 0, 0)
|
| impl = <class 'sqlalchemy.sql.sqltypes.DateTime'>
| A type for ``datetime.datetime()`` objects.
|
| Date and time types return objects from the Python ``datetime``
| module. Most DBAPIs have built in support for the datetime
| module, with the noted exception of SQLite. In the case of
| SQLite, date and time types are stored as strings which are then
| converted back to datetime objects when rows are returned.
|
| For the time representation within the datetime type, some
| backends include additional options, such as timezone support and
| fractional seconds support. For fractional seconds, use the
| dialect-specific datatype, such as :class:`.mysql.TIME`. For
| timezone support, use at least the :class:`_types.TIMESTAMP` datatype,
| if not the dialect-specific datatype object.
|
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.Emulated:
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.type_api.Emulated:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeDecorator:
|
| __getattr__(self, key: 'str') -> 'Any'
| Proxy all other undefined accessors to the underlying
| implementation.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| bind_expression(self, bindparam: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression which will typically wrap the given parameter.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** necessarily
| called against specific values, and should not be confused with the
| :meth:`_types.TypeDecorator.process_bind_param` method, which is
| the more typical method that processes the actual value passed to a
| particular parameter at statement execution time.
|
| Subclasses of :class:`_types.TypeDecorator` can override this method
| to provide custom bind expression behavior for the type. This
| implementation will **replace** that of the underlying implementation
| type.
|
| column_expression(self, column: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a SELECT column expression, return a wrapping SQL expression.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values, and should not be confused with the
| :meth:`_types.TypeDecorator.process_result_value` method, which is
| the more typical method that processes the actual value returned
| in a result row subsequent to statement execution time.
|
| Subclasses of :class:`_types.TypeDecorator` can override this method
| to provide custom column expression behavior for the type. This
| implementation will **replace** that of the underlying implementation
| type.
|
| See the description of :meth:`_types.TypeEngine.column_expression`
| for a complete description of the method's use.
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Given two values, compare them for equality.
|
| By default this calls upon :meth:`.TypeEngine.compare_values`
| of the underlying "impl", which in turn usually
| uses the Python equals operator ``==``.
|
| This function is used by the ORM to compare
| an original-loaded value with an intercepted
| "changed" value, to determine if a net change
| has occurred.
|
| copy(self, **kw: 'Any') -> 'Self'
| Produce a copy of this :class:`.TypeDecorator` instance.
|
| This is a shallow copy and is provided to fulfill part of
| the :class:`.TypeEngine` contract. It usually does not
| need to be overridden unless the user-defined :class:`.TypeDecorator`
| has local state that should be deep-copied.
|
| get_dbapi_type(self, dbapi: 'DBAPIModule') -> 'Optional[Any]'
| Return the DBAPI type object represented by this
| :class:`.TypeDecorator`.
|
| By default this calls upon :meth:`.TypeEngine.get_dbapi_type` of the
| underlying "impl".
|
| impl_instance(...)
|
| literal_processor(self, dialect: 'Dialect') -> 'Optional[_LiteralProcessorType[_T]]'
| Provide a literal processing function for the given
| :class:`.Dialect`.
|
| This is the method that fulfills the :class:`.TypeEngine`
| contract for literal value conversion which normally occurs via
| the :meth:`_types.TypeEngine.literal_processor` method.
|
| .. note::
|
| User-defined subclasses of :class:`_types.TypeDecorator` should
| **not** implement this method, and should instead implement
| :meth:`_types.TypeDecorator.process_literal_param` so that the
| "inner" processing provided by the implementing type is maintained.
|
| load_dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[Any]'
| Return a :class:`.TypeEngine` object corresponding to a dialect.
|
| This is an end-user override hook that can be used to provide
| differing types depending on the given dialect. It is used
| by the :class:`.TypeDecorator` implementation of :meth:`type_engine`
| to help determine what type should ultimately be returned
| for a given :class:`.TypeDecorator`.
|
| By default returns ``self.impl``.
|
| process_bind_param(self, value: 'Optional[_T]', dialect: 'Dialect') -> 'Any'
| Receive a bound parameter value to be converted.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for incoming data values.
| This method is called at **statement execution time** and is passed
| the literal Python data value which is to be associated with a bound
| parameter in the statement.
|
| The operation could be anything desired to perform custom
| behavior, such as transforming or serializing data.
| This could also be used as a hook for validating logic.
|
| :param value: Data to operate upon, of any type expected by
| this method in the subclass. Can be ``None``.
| :param dialect: the :class:`.Dialect` in use.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| :meth:`_types.TypeDecorator.process_result_value`
|
| process_literal_param(self, value: 'Optional[_T]', dialect: 'Dialect') -> 'str'
| Receive a literal parameter value to be rendered inline within
| a statement.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. Unlike other SQL
| compilation methods, it is passed a specific Python value to be
| rendered as a string. However it should not be confused with the
| :meth:`_types.TypeDecorator.process_bind_param` method, which is
| the more typical method that processes the actual value passed to a
| particular parameter at statement execution time.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for incoming data values
| that are in the special case of being rendered as literals.
|
| The returned string will be rendered into the output string.
|
| process_result_value(self, value: 'Optional[Any]', dialect: 'Dialect') -> 'Optional[_T]'
| Receive a result-row column value to be converted.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for data values
| being received in result rows coming from the database.
| This method is called at **result fetching time** and is passed
| the literal Python data value that's extracted from a database result
| row.
|
| The operation could be anything desired to perform custom
| behavior, such as transforming or deserializing data.
|
| :param value: Data to operate upon, of any type expected by
| this method in the subclass. Can be ``None``.
| :param dialect: the :class:`.Dialect` in use.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| :meth:`_types.TypeDecorator.process_bind_param`
|
| type_engine(self, dialect: 'Dialect') -> 'TypeEngine[Any]'
| Return a dialect-specific :class:`.TypeEngine` instance
| for this :class:`.TypeDecorator`.
|
| In most cases this returns a dialect-adapted form of
| the :class:`.TypeEngine` type represented by ``self.impl``.
| Makes usage of :meth:`dialect_impl`.
| Behavior can be customized here by overriding
| :meth:`load_dialect_impl`.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.type_api.TypeDecorator:
|
| sort_key_function
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeDecorator:
|
| __visit_name__ = 'type_decorator'
|
| coerce_to_is_types = (<class 'NoneType'>,)
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __str__(self) -> 'str'
| Return str(self).
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.JSON
Python Library Documentation: class JSON in module sqlalchemy.sql.sqltypes
class JSON(Indexable, sqlalchemy.sql.type_api.TypeEngine)
| JSON(none_as_null: 'bool' = False)
|
| Represent a SQL JSON type.
|
| .. note:: :class:`_types.JSON`
| is provided as a facade for vendor-specific
| JSON types. Since it supports JSON SQL operations, it only
| works on backends that have an actual JSON type, currently:
|
| * PostgreSQL - see :class:`sqlalchemy.dialects.postgresql.JSON` and
| :class:`sqlalchemy.dialects.postgresql.JSONB` for backend-specific
| notes
|
| * MySQL - see
| :class:`sqlalchemy.dialects.mysql.JSON` for backend-specific notes
|
| * SQLite as of version 3.9 - see
| :class:`sqlalchemy.dialects.sqlite.JSON` for backend-specific notes
|
| * Microsoft SQL Server 2016 and later - see
| :class:`sqlalchemy.dialects.mssql.JSON` for backend-specific notes
|
| :class:`_types.JSON` is part of the Core in support of the growing
| popularity of native JSON datatypes.
|
| The :class:`_types.JSON` type stores arbitrary JSON format data, e.g.::
|
| data_table = Table(
| "data_table",
| metadata,
| Column("id", Integer, primary_key=True),
| Column("data", JSON),
| )
|
| with engine.connect() as conn:
| conn.execute(
| data_table.insert(), {"data": {"key1": "value1", "key2": "value2"}}
| )
|
| **JSON-Specific Expression Operators**
|
| The :class:`_types.JSON`
| datatype provides these additional SQL operations:
|
| * Keyed index operations::
|
| data_table.c.data["some key"]
|
| * Integer index operations::
|
| data_table.c.data[3]
|
| * Path index operations::
|
| data_table.c.data[("key_1", "key_2", 5, ..., "key_n")]
|
| * Data casters for specific JSON element types, subsequent to an index
| or path operation being invoked::
|
| data_table.c.data["some key"].as_integer()
|
| .. versionadded:: 1.3.11
|
| Additional operations may be available from the dialect-specific versions
| of :class:`_types.JSON`, such as
| :class:`sqlalchemy.dialects.postgresql.JSON` and
| :class:`sqlalchemy.dialects.postgresql.JSONB` which both offer additional
| PostgreSQL-specific operations.
|
| **Casting JSON Elements to Other Types**
|
| Index operations, i.e. those invoked by calling upon the expression using
| the Python bracket operator as in ``some_column['some key']``, return an
| expression object whose type defaults to :class:`_types.JSON` by default,
| so that
| further JSON-oriented instructions may be called upon the result type.
| However, it is likely more common that an index operation is expected
| to return a specific scalar element, such as a string or integer. In
| order to provide access to these elements in a backend-agnostic way,
| a series of data casters are provided:
|
| * :meth:`.JSON.Comparator.as_string` - return the element as a string
|
| * :meth:`.JSON.Comparator.as_boolean` - return the element as a boolean
|
| * :meth:`.JSON.Comparator.as_float` - return the element as a float
|
| * :meth:`.JSON.Comparator.as_integer` - return the element as an integer
|
| These data casters are implemented by supporting dialects in order to
| assure that comparisons to the above types will work as expected, such as::
|
| # integer comparison
| data_table.c.data["some_integer_key"].as_integer() == 5
|
| # boolean comparison
| data_table.c.data["some_boolean"].as_boolean() == True
|
| .. versionadded:: 1.3.11 Added type-specific casters for the basic JSON
| data element types.
|
| .. note::
|
| The data caster functions are new in version 1.3.11, and supersede
| the previous documented approaches of using CAST; for reference,
| this looked like::
|
| from sqlalchemy import cast, type_coerce
| from sqlalchemy import String, JSON
|
| cast(data_table.c.data["some_key"], String) == type_coerce(55, JSON)
|
| The above case now works directly as::
|
| data_table.c.data["some_key"].as_integer() == 5
|
| For details on the previous comparison approach within the 1.3.x
| series, see the documentation for SQLAlchemy 1.2 or the included HTML
| files in the doc/ directory of the version's distribution.
|
| **Detecting Changes in JSON columns when using the ORM**
|
| The :class:`_types.JSON` type, when used with the SQLAlchemy ORM, does not
| detect in-place mutations to the structure. In order to detect these, the
| :mod:`sqlalchemy.ext.mutable` extension must be used, most typically
| using the :class:`.MutableDict` class. This extension will
| allow "in-place" changes to the datastructure to produce events which
| will be detected by the unit of work. See the example at :class:`.HSTORE`
| for a simple example involving a dictionary.
|
| Alternatively, assigning a JSON structure to an ORM element that
| replaces the old one will always trigger a change event.
|
| **Support for JSON null vs. SQL NULL**
|
| When working with NULL values, the :class:`_types.JSON` type recommends the
| use of two specific constants in order to differentiate between a column
| that evaluates to SQL NULL, e.g. no value, vs. the JSON-encoded string of
| ``"null"``. To insert or select against a value that is SQL NULL, use the
| constant :func:`.null`. This symbol may be passed as a parameter value
| specifically when using the :class:`_types.JSON` datatype, which contains
| special logic that interprets this symbol to mean that the column value
| should be SQL NULL as opposed to JSON ``"null"``::
|
| from sqlalchemy import null
|
| conn.execute(table.insert(), {"json_value": null()})
|
| To insert or select against a value that is JSON ``"null"``, use the
| constant :attr:`_types.JSON.NULL`::
|
| conn.execute(table.insert(), {"json_value": JSON.NULL})
|
| The :class:`_types.JSON` type supports a flag
| :paramref:`_types.JSON.none_as_null` which when set to True will result
| in the Python constant ``None`` evaluating to the value of SQL
| NULL, and when set to False results in the Python constant
| ``None`` evaluating to the value of JSON ``"null"``. The Python
| value ``None`` may be used in conjunction with either
| :attr:`_types.JSON.NULL` and :func:`.null` in order to indicate NULL
| values, but care must be taken as to the value of the
| :paramref:`_types.JSON.none_as_null` in these cases.
|
| **Customizing the JSON Serializer**
|
| The JSON serializer and deserializer used by :class:`_types.JSON`
| defaults to
| Python's ``json.dumps`` and ``json.loads`` functions; in the case of the
| psycopg2 dialect, psycopg2 may be using its own custom loader function.
|
| In order to affect the serializer / deserializer, they are currently
| configurable at the :func:`_sa.create_engine` level via the
| :paramref:`_sa.create_engine.json_serializer` and
| :paramref:`_sa.create_engine.json_deserializer` parameters. For example,
| to turn off ``ensure_ascii``::
|
| engine = create_engine(
| "sqlite://",
| json_serializer=lambda obj: json.dumps(obj, ensure_ascii=False),
| )
|
| .. versionchanged:: 1.3.7
|
| SQLite dialect's ``json_serializer`` and ``json_deserializer``
| parameters renamed from ``_json_serializer`` and
| ``_json_deserializer``.
|
| .. seealso::
|
| :class:`sqlalchemy.dialects.postgresql.JSON`
|
| :class:`sqlalchemy.dialects.postgresql.JSONB`
|
| :class:`sqlalchemy.dialects.mysql.JSON`
|
| :class:`sqlalchemy.dialects.sqlite.JSON`
|
| Method resolution order:
| JSON
| Indexable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, none_as_null: 'bool' = False)
| Construct a :class:`_types.JSON` type.
|
| :param none_as_null=False: 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 :func:`.null` construct can still be used to
| persist a NULL value, which may be passed directly as a parameter
| value that is specially interpreted by the :class:`_types.JSON` type
| as SQL NULL::
|
| from sqlalchemy import null
|
| conn.execute(table.insert(), {"data": null()})
|
| .. note::
|
| :paramref:`_types.JSON.none_as_null` does **not** apply to the
| values passed to :paramref:`_schema.Column.default` and
| :paramref:`_schema.Column.server_default`; a value of ``None``
| passed for these parameters means "no default present".
|
| Additionally, when used in SQL comparison expressions, the
| Python value ``None`` continues to refer to SQL null, and not
| JSON NULL. The :paramref:`_types.JSON.none_as_null` flag refers
| explicitly to the **persistence** of the value within an
| INSERT or UPDATE statement. The :attr:`_types.JSON.NULL`
| value should be used for SQL expressions that wish to compare to
| JSON null.
|
| .. seealso::
|
| :attr:`.types.JSON.NULL`
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| should_evaluate_none
| Alias of :attr:`_types.JSON.none_as_null`
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.JSON.Comparator'>
| Define comparison operations for :class:`_types.JSON`.
|
|
| JSONElementType = <class 'sqlalchemy.sql.sqltypes.JSON.JSONElementType...
| Common function for index / path elements in a JSON expression.
|
|
| JSONIndexType = <class 'sqlalchemy.sql.sqltypes.JSON.JSONIndexType'>
| Placeholder for the datatype of a JSON index value.
|
| This allows execution-time processing of JSON index values
| for special syntaxes.
|
|
| JSONIntIndexType = <class 'sqlalchemy.sql.sqltypes.JSON.JSONIntIndexTy...
| Placeholder for the datatype of a JSON index value.
|
| This allows execution-time processing of JSON index values
| for special syntaxes.
|
|
| JSONPathType = <class 'sqlalchemy.sql.sqltypes.JSON.JSONPathType'>
| Placeholder type for JSON path operations.
|
| This allows execution-time processing of a path-based
| index value into a specific SQL syntax.
|
|
| JSONStrIndexType = <class 'sqlalchemy.sql.sqltypes.JSON.JSONStrIndexTy...
| Placeholder for the datatype of a JSON index value.
|
| This allows execution-time processing of JSON index values
| for special syntaxes.
|
|
| NULL = symbol('JSON_NULL')
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'JSON'
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.JSON.Comparator'>
| Define comparison operations for :class:`_types.JSON`.
|
|
| hashable = False
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Indexable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| get_dbapi_type(self, dbapi: 'DBAPIModule') -> 'Optional[Any]'
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect: 'Dialect') -> 'Optional[_LiteralProcessorType[_T]]'
| 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.
|
| .. tip::
|
| 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`
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.LABEL_STYLE_DEFAULT
Python Library Documentation: SelectLabelStyle in module sqlalchemy.sql.selectable object class SelectLabelStyle(enum.Enum) | SelectLabelStyle(*values) | | Label style constants that may be passed to | :meth:`_sql.Select.set_label_style`. | | Method resolution order: | SelectLabelStyle | enum.Enum | builtins.object | | Data and other attributes defined here: | | LABEL_STYLE_DISAMBIGUATE_ONLY = <SelectLabelStyle.LABEL_STYLE_DISAMBIG... | | LABEL_STYLE_LEGACY_ORM = <SelectLabelStyle.LABEL_STYLE_LEGACY_ORM: 3> | | LABEL_STYLE_NONE = <SelectLabelStyle.LABEL_STYLE_NONE: 0> | | LABEL_STYLE_TABLENAME_PLUS_COL = <SelectLabelStyle.LABEL_STYLE_TABLENA... | | ---------------------------------------------------------------------- | Data descriptors inherited from enum.Enum: | | name | The name of the Enum member. | | value | The value of the Enum member. | | ---------------------------------------------------------------------- | Static methods inherited from enum.EnumType: | | __contains__(value) | Return True if `value` is in `cls`. | | `value` is in `cls` if: | 1) `value` is a member of `cls`, or | 2) `value` is the value of one of the `cls`'s members. | | __getitem__(name) | Return the member matching `name`. | | __iter__() | Return members in definition order. | | __len__() | Return the number of members (no aliases) | | ---------------------------------------------------------------------- | Readonly properties inherited from enum.EnumType: | | __members__ | Returns a mapping of member name->value. | | This mapping lists all enum members, including aliases. Note that this | is a read-only view of the internal mapping.
sqlmodel.LABEL_STYLE_DISAMBIGUATE_ONLY
Python Library Documentation: SelectLabelStyle in module sqlalchemy.sql.selectable object class SelectLabelStyle(enum.Enum) | SelectLabelStyle(*values) | | Label style constants that may be passed to | :meth:`_sql.Select.set_label_style`. | | Method resolution order: | SelectLabelStyle | enum.Enum | builtins.object | | Data and other attributes defined here: | | LABEL_STYLE_DISAMBIGUATE_ONLY = <SelectLabelStyle.LABEL_STYLE_DISAMBIG... | | LABEL_STYLE_LEGACY_ORM = <SelectLabelStyle.LABEL_STYLE_LEGACY_ORM: 3> | | LABEL_STYLE_NONE = <SelectLabelStyle.LABEL_STYLE_NONE: 0> | | LABEL_STYLE_TABLENAME_PLUS_COL = <SelectLabelStyle.LABEL_STYLE_TABLENA... | | ---------------------------------------------------------------------- | Data descriptors inherited from enum.Enum: | | name | The name of the Enum member. | | value | The value of the Enum member. | | ---------------------------------------------------------------------- | Static methods inherited from enum.EnumType: | | __contains__(value) | Return True if `value` is in `cls`. | | `value` is in `cls` if: | 1) `value` is a member of `cls`, or | 2) `value` is the value of one of the `cls`'s members. | | __getitem__(name) | Return the member matching `name`. | | __iter__() | Return members in definition order. | | __len__() | Return the number of members (no aliases) | | ---------------------------------------------------------------------- | Readonly properties inherited from enum.EnumType: | | __members__ | Returns a mapping of member name->value. | | This mapping lists all enum members, including aliases. Note that this | is a read-only view of the internal mapping.
sqlmodel.LABEL_STYLE_NONE
Python Library Documentation: SelectLabelStyle in module sqlalchemy.sql.selectable object class SelectLabelStyle(enum.Enum) | SelectLabelStyle(*values) | | Label style constants that may be passed to | :meth:`_sql.Select.set_label_style`. | | Method resolution order: | SelectLabelStyle | enum.Enum | builtins.object | | Data and other attributes defined here: | | LABEL_STYLE_DISAMBIGUATE_ONLY = <SelectLabelStyle.LABEL_STYLE_DISAMBIG... | | LABEL_STYLE_LEGACY_ORM = <SelectLabelStyle.LABEL_STYLE_LEGACY_ORM: 3> | | LABEL_STYLE_NONE = <SelectLabelStyle.LABEL_STYLE_NONE: 0> | | LABEL_STYLE_TABLENAME_PLUS_COL = <SelectLabelStyle.LABEL_STYLE_TABLENA... | | ---------------------------------------------------------------------- | Data descriptors inherited from enum.Enum: | | name | The name of the Enum member. | | value | The value of the Enum member. | | ---------------------------------------------------------------------- | Static methods inherited from enum.EnumType: | | __contains__(value) | Return True if `value` is in `cls`. | | `value` is in `cls` if: | 1) `value` is a member of `cls`, or | 2) `value` is the value of one of the `cls`'s members. | | __getitem__(name) | Return the member matching `name`. | | __iter__() | Return members in definition order. | | __len__() | Return the number of members (no aliases) | | ---------------------------------------------------------------------- | Readonly properties inherited from enum.EnumType: | | __members__ | Returns a mapping of member name->value. | | This mapping lists all enum members, including aliases. Note that this | is a read-only view of the internal mapping.
sqlmodel.LABEL_STYLE_TABLENAME_PLUS_COL
Python Library Documentation: SelectLabelStyle in module sqlalchemy.sql.selectable object class SelectLabelStyle(enum.Enum) | SelectLabelStyle(*values) | | Label style constants that may be passed to | :meth:`_sql.Select.set_label_style`. | | Method resolution order: | SelectLabelStyle | enum.Enum | builtins.object | | Data and other attributes defined here: | | LABEL_STYLE_DISAMBIGUATE_ONLY = <SelectLabelStyle.LABEL_STYLE_DISAMBIG... | | LABEL_STYLE_LEGACY_ORM = <SelectLabelStyle.LABEL_STYLE_LEGACY_ORM: 3> | | LABEL_STYLE_NONE = <SelectLabelStyle.LABEL_STYLE_NONE: 0> | | LABEL_STYLE_TABLENAME_PLUS_COL = <SelectLabelStyle.LABEL_STYLE_TABLENA... | | ---------------------------------------------------------------------- | Data descriptors inherited from enum.Enum: | | name | The name of the Enum member. | | value | The value of the Enum member. | | ---------------------------------------------------------------------- | Static methods inherited from enum.EnumType: | | __contains__(value) | Return True if `value` is in `cls`. | | `value` is in `cls` if: | 1) `value` is a member of `cls`, or | 2) `value` is the value of one of the `cls`'s members. | | __getitem__(name) | Return the member matching `name`. | | __iter__() | Return members in definition order. | | __len__() | Return the number of members (no aliases) | | ---------------------------------------------------------------------- | Readonly properties inherited from enum.EnumType: | | __members__ | Returns a mapping of member name->value. | | This mapping lists all enum members, including aliases. Note that this | is a read-only view of the internal mapping.
sqlmodel.LargeBinary
Python Library Documentation: class LargeBinary in module sqlalchemy.sql.sqltypes
class LargeBinary(_Binary)
| LargeBinary(length: 'Optional[int]' = None)
|
| A type for large binary byte data.
|
| The :class:`.LargeBinary` type corresponds to a large and/or unlengthed
| binary type for the target platform, such as BLOB on MySQL and BYTEA for
| PostgreSQL. It also handles the necessary conversions for the DBAPI.
|
| Method resolution order:
| LargeBinary
| _Binary
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, length: 'Optional[int]' = None)
| Construct a LargeBinary type.
|
| :param length: optional, a length for the column for use in
| DDL statements, for those binary types that accept a length,
| such as the MySQL BLOB type.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'large_binary'
|
| ----------------------------------------------------------------------
| Methods inherited from _Binary:
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op, value)
| See :meth:`.TypeEngine.coerce_compared_value` for a description.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from _Binary:
|
| 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.
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeEngine.Comparator'>
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| comparator_factory = <class 'sqlalchemy.sql.type_api.TypeEngine.Compar...
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| Function to initialize subclasses.
sqlmodel.MetaData
Python Library Documentation: class MetaData in module sqlalchemy.sql.schema
class MetaData(HasSchemaAttr)
| MetaData(schema: 'Optional[str]' = None, quote_schema: 'Optional[bool]' = None, naming_convention: 'Optional[_NamingSchemaParameter]' = None, info: 'Optional[_InfoType]' = None) -> 'None'
|
| A collection of :class:`_schema.Table`
| objects and their associated schema
| constructs.
|
| Holds a collection of :class:`_schema.Table` objects as well as
| an optional binding to an :class:`_engine.Engine` or
| :class:`_engine.Connection`. If bound, the :class:`_schema.Table` objects
| in the collection and their columns may participate in implicit SQL
| execution.
|
| The :class:`_schema.Table` objects themselves are stored in the
| :attr:`_schema.MetaData.tables` dictionary.
|
| :class:`_schema.MetaData` is a thread-safe object for read operations.
| Construction of new tables within a single :class:`_schema.MetaData`
| object,
| either explicitly or via reflection, may not be completely thread-safe.
|
| .. seealso::
|
| :ref:`metadata_describing` - Introduction to database metadata
|
| Method resolution order:
| MetaData
| HasSchemaAttr
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __contains__(self, table_or_key: 'Union[str, Table]') -> 'bool'
|
| __getstate__(self) -> 'Dict[str, Any]'
| Helper for pickle.
|
| __init__(self, schema: 'Optional[str]' = None, quote_schema: 'Optional[bool]' = None, naming_convention: 'Optional[_NamingSchemaParameter]' = None, info: 'Optional[_InfoType]' = None) -> 'None'
| Create a new MetaData object.
|
| :param schema:
| The default schema to use for the :class:`_schema.Table`,
| :class:`.Sequence`, and potentially other objects associated with
| this :class:`_schema.MetaData`. Defaults to ``None``.
|
| .. seealso::
|
| :ref:`schema_metadata_schema_name` - details on how the
| :paramref:`_schema.MetaData.schema` parameter is used.
|
| :paramref:`_schema.Table.schema`
|
| :paramref:`.Sequence.schema`
|
| :param quote_schema:
| Sets the ``quote_schema`` flag for those :class:`_schema.Table`,
| :class:`.Sequence`, and other objects which make usage of the
| local ``schema`` name.
|
| :param info: Optional data dictionary which will be populated into the
| :attr:`.SchemaItem.info` attribute of this object.
|
| :param naming_convention: a dictionary referring to values which
| will establish default naming conventions for :class:`.Constraint`
| and :class:`.Index` objects, for those objects which are not given
| a name explicitly.
|
| The keys of this dictionary may be:
|
| * a constraint or Index class, e.g. the :class:`.UniqueConstraint`,
| :class:`_schema.ForeignKeyConstraint` class, the :class:`.Index`
| class
|
| * a string mnemonic for one of the known constraint classes;
| ``"fk"``, ``"pk"``, ``"ix"``, ``"ck"``, ``"uq"`` for foreign key,
| primary key, index, check, and unique constraint, respectively.
|
| * the string name of a user-defined "token" that can be used
| to define new naming tokens.
|
| The values associated with each "constraint class" or "constraint
| mnemonic" key are string naming templates, such as
| ``"uq_%(table_name)s_%(column_0_name)s"``,
| which describe how the name should be composed. The values
| associated with user-defined "token" keys should be callables of the
| form ``fn(constraint, table)``, which accepts the constraint/index
| object and :class:`_schema.Table` as arguments, returning a string
| result.
|
| The built-in names are as follows, some of which may only be
| available for certain types of constraint:
|
| * ``%(table_name)s`` - the name of the :class:`_schema.Table`
| object
| associated with the constraint.
|
| * ``%(referred_table_name)s`` - the name of the
| :class:`_schema.Table`
| object associated with the referencing target of a
| :class:`_schema.ForeignKeyConstraint`.
|
| * ``%(column_0_name)s`` - the name of the :class:`_schema.Column`
| at
| index position "0" within the constraint.
|
| * ``%(column_0N_name)s`` - the name of all :class:`_schema.Column`
| objects in order within the constraint, joined without a
| separator.
|
| * ``%(column_0_N_name)s`` - the name of all
| :class:`_schema.Column`
| objects in order within the constraint, joined with an
| underscore as a separator.
|
| * ``%(column_0_label)s``, ``%(column_0N_label)s``,
| ``%(column_0_N_label)s`` - the label of either the zeroth
| :class:`_schema.Column` or all :class:`.Columns`, separated with
| or without an underscore
|
| * ``%(column_0_key)s``, ``%(column_0N_key)s``,
| ``%(column_0_N_key)s`` - the key of either the zeroth
| :class:`_schema.Column` or all :class:`.Columns`, separated with
| or without an underscore
|
| * ``%(referred_column_0_name)s``, ``%(referred_column_0N_name)s``
| ``%(referred_column_0_N_name)s``, ``%(referred_column_0_key)s``,
| ``%(referred_column_0N_key)s``, ... column tokens which
| render the names/keys/labels of columns that are referenced
| by a :class:`_schema.ForeignKeyConstraint`.
|
| * ``%(constraint_name)s`` - a special key that refers to the
| existing name given to the constraint. When this key is
| present, the :class:`.Constraint` object's existing name will be
| replaced with one that is composed from template string that
| uses this token. When this token is present, it is required that
| the :class:`.Constraint` is given an explicit name ahead of time.
|
| * user-defined: any additional token may be implemented by passing
| it along with a ``fn(constraint, table)`` callable to the
| naming_convention dictionary.
|
| .. versionadded:: 1.3.0 - added new ``%(column_0N_name)s``,
| ``%(column_0_N_name)s``, and related tokens that produce
| concatenations of names, keys, or labels for all columns referred
| to by a given constraint.
|
| .. seealso::
|
| :ref:`constraint_naming_conventions` - for detailed usage
| examples.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __setstate__(self, state: 'Dict[str, Any]') -> 'None'
|
| clear(self) -> 'None'
| Clear all Table objects from this MetaData.
|
| create_all(self, bind: '_CreateDropBind', tables: 'Optional[_typing_Sequence[Table]]' = None, checkfirst: 'bool' = True) -> 'None'
| Create all tables stored in this metadata.
|
| Conditional by default, will not attempt to recreate tables already
| present in the target database.
|
| :param bind:
| A :class:`.Connection` or :class:`.Engine` used to access the
| database.
|
| :param tables:
| Optional list of ``Table`` objects, which is a subset of the total
| tables in the ``MetaData`` (others are ignored).
|
| :param checkfirst:
| Defaults to True, don't issue CREATEs for tables already present
| in the target database.
|
| drop_all(self, bind: '_CreateDropBind', tables: 'Optional[_typing_Sequence[Table]]' = None, checkfirst: 'bool' = True) -> 'None'
| Drop all tables stored in this metadata.
|
| Conditional by default, will not attempt to drop tables not present in
| the target database.
|
| :param bind:
| A :class:`.Connection` or :class:`.Engine` used to access the
| database.
|
| :param tables:
| Optional list of ``Table`` objects, which is a subset of the
| total tables in the ``MetaData`` (others are ignored).
|
| :param checkfirst:
| Defaults to True, only issue DROPs for tables confirmed to be
| present in the target database.
|
| reflect(self, bind: 'Union[Engine, Connection]', schema: 'Optional[str]' = None, views: 'bool' = False, only: 'Union[_typing_Sequence[str], Callable[[str, MetaData], bool], None]' = None, extend_existing: 'bool' = False, autoload_replace: 'bool' = True, resolve_fks: 'bool' = True, **dialect_kwargs: 'Any') -> 'None'
| Load all available table definitions from the database.
|
| Automatically creates ``Table`` entries in this ``MetaData`` for any
| table available in the database but not yet present in the
| ``MetaData``. May be called multiple times to pick up tables recently
| added to the database, however no special action is taken if a table
| in this ``MetaData`` no longer exists in the database.
|
| :param bind:
| A :class:`.Connection` or :class:`.Engine` used to access the
| database.
|
| :param schema:
| Optional, query and reflect tables from an alternate schema.
| If None, the schema associated with this :class:`_schema.MetaData`
| is used, if any.
|
| :param views:
| If True, also reflect views (materialized and plain).
|
| :param only:
| Optional. Load only a sub-set of available named tables. May be
| specified as a sequence of names or a callable.
|
| If a sequence of names is provided, only those tables will be
| reflected. An error is raised if a table is requested but not
| available. Named tables already present in this ``MetaData`` are
| ignored.
|
| If a callable is provided, it will be used as a boolean predicate to
| filter the list of potential table names. The callable is called
| with a table name and this ``MetaData`` instance as positional
| arguments and should return a true value for any table to reflect.
|
| :param extend_existing: Passed along to each :class:`_schema.Table` as
| :paramref:`_schema.Table.extend_existing`.
|
| :param autoload_replace: Passed along to each :class:`_schema.Table`
| as
| :paramref:`_schema.Table.autoload_replace`.
|
| :param resolve_fks: if True, reflect :class:`_schema.Table`
| objects linked
| to :class:`_schema.ForeignKey` objects located in each
| :class:`_schema.Table`.
| For :meth:`_schema.MetaData.reflect`,
| this has the effect of reflecting
| related tables that might otherwise not be in the list of tables
| being reflected, for example if the referenced table is in a
| different schema or is omitted via the
| :paramref:`.MetaData.reflect.only` parameter. When False,
| :class:`_schema.ForeignKey` objects are not followed to the
| :class:`_schema.Table`
| in which they link, however if the related table is also part of the
| list of tables that would be reflected in any case, the
| :class:`_schema.ForeignKey` object will still resolve to its related
| :class:`_schema.Table` after the :meth:`_schema.MetaData.reflect`
| operation is
| complete. Defaults to True.
|
| .. versionadded:: 1.3.0
|
| .. seealso::
|
| :paramref:`_schema.Table.resolve_fks`
|
| :param \**dialect_kwargs: Additional keyword arguments not mentioned
| above are dialect specific, and passed in the form
| ``<dialectname>_<argname>``. See the documentation regarding an
| individual dialect at :ref:`dialect_toplevel` for detail on
| documented arguments.
|
| .. seealso::
|
| :ref:`metadata_reflection_toplevel`
|
| :meth:`_events.DDLEvents.column_reflect` - Event used to customize
| the reflected columns. Usually used to generalize the types using
| :meth:`_types.TypeEngine.as_generic`
|
| :ref:`metadata_reflection_dbagnostic_types` - describes how to
| reflect tables using general types.
|
| remove(self, table: 'Table') -> 'None'
| Remove the given Table object from this MetaData.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| sorted_tables
| Returns a list of :class:`_schema.Table` objects sorted in order of
| foreign key dependency.
|
| The sorting will place :class:`_schema.Table`
| objects that have dependencies
| first, before the dependencies themselves, representing the
| order in which they can be created. To get the order in which
| the tables would be dropped, use the ``reversed()`` Python built-in.
|
| .. warning::
|
| The :attr:`.MetaData.sorted_tables` attribute cannot by itself
| accommodate automatic resolution of dependency cycles between
| tables, which are usually caused by mutually dependent foreign key
| constraints. When these cycles are detected, the foreign keys
| of these tables are omitted from consideration in the sort.
| A warning is emitted when this condition occurs, which will be an
| exception raise in a future release. Tables which are not part
| of the cycle will still be returned in dependency order.
|
| To resolve these cycles, the
| :paramref:`_schema.ForeignKeyConstraint.use_alter` parameter may be
| applied to those constraints which create a cycle. Alternatively,
| the :func:`_schema.sort_tables_and_constraints` function will
| automatically return foreign key constraints in a separate
| collection when cycles are detected so that they may be applied
| to a schema separately.
|
| .. versionchanged:: 1.3.17 - a warning is emitted when
| :attr:`.MetaData.sorted_tables` cannot perform a proper sort
| due to cyclical dependencies. This will be an exception in a
| future release. Additionally, the sort will continue to return
| other tables not involved in the cycle in dependency order which
| was not the case previously.
|
| .. seealso::
|
| :func:`_schema.sort_tables`
|
| :func:`_schema.sort_tables_and_constraints`
|
| :attr:`_schema.MetaData.tables`
|
| :meth:`_reflection.Inspector.get_table_names`
|
| :meth:`_reflection.Inspector.get_sorted_table_and_fkc_names`
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'tables': 'util.FacadeDict[str, Table]'}
|
| __visit_name__ = 'metadata'
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.NCHAR
Python Library Documentation: class NCHAR in module sqlalchemy.sql.sqltypes
class NCHAR(Unicode)
| NCHAR(length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
|
| The SQL NCHAR type.
|
| Method resolution order:
| NCHAR
| Unicode
| String
| Concatenable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'NCHAR'
|
| ----------------------------------------------------------------------
| Methods inherited from String:
|
| __init__(self, length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
| Create a string-holding type.
|
| :param length: optional, a length for the column for use in
| DDL and CAST expressions. May be safely omitted if no ``CREATE
| TABLE`` will be issued. Certain databases may require a
| ``length`` for use in DDL, and will raise an exception when
| the ``CREATE TABLE`` DDL is issued if a ``VARCHAR``
| with no length is included. Whether the value is
| interpreted as bytes or characters is database specific.
|
| :param collation: Optional, a column-level collation for
| use in DDL and CAST expressions. Renders using the
| COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
| E.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> from sqlalchemy import cast, select, String
| >>> print(select(cast("some string", String(collation="utf8"))))
| {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
|
| .. note::
|
| In most cases, the :class:`.Unicode` or :class:`.UnicodeText`
| datatypes should be used for a :class:`_schema.Column` that expects
| to store non-ascii data. These datatypes will ensure that the
| correct types are used on the database.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from String:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Concatenable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Concatenable:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comparator'>
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comp...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.NUMERIC
Python Library Documentation: class NUMERIC in module sqlalchemy.sql.sqltypes
class NUMERIC(Numeric)
| NUMERIC(precision: 'Optional[int]' = None, scale: 'Optional[int]' = None, decimal_return_scale: 'Optional[int]' = None, asdecimal: 'bool' = True)
|
| The SQL NUMERIC type.
|
| .. seealso::
|
| :class:`_types.Numeric` - documentation for the base type.
|
| Method resolution order:
| NUMERIC
| Numeric
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'NUMERIC'
|
| ----------------------------------------------------------------------
| Methods inherited from Numeric:
|
| __init__(self, precision: 'Optional[int]' = None, scale: 'Optional[int]' = None, decimal_return_scale: 'Optional[int]' = None, asdecimal: 'bool' = True)
| Construct a Numeric.
|
| :param precision: the numeric precision for use in DDL ``CREATE
| TABLE``.
|
| :param scale: the numeric scale for use in DDL ``CREATE TABLE``.
|
| :param asdecimal: default True. Return whether or not
| values should be sent as Python Decimal objects, or
| as floats. Different DBAPIs send one or the other based on
| datatypes - the Numeric type will ensure that return values
| are one or the other across DBAPIs consistently.
|
| :param decimal_return_scale: Default scale to use when converting
| from floats to Python decimals. Floating point values will typically
| be much longer due to decimal inaccuracy, and most floating point
| database types don't have a notion of "scale", so by default the
| float type looks for the first ten decimal places when converting.
| Specifying this value will override that length. Types which
| do include an explicit ".scale" value, such as the base
| :class:`.Numeric` as well as the MySQL float types, will use the
| value of ".scale" as the default for decimal_return_scale, if not
| otherwise specified.
|
| When using the ``Numeric`` type, care should be taken to ensure
| that the asdecimal setting is appropriate for the DBAPI in use -
| when Numeric applies a conversion from Decimal->float or float->
| Decimal, this conversion incurs an additional performance overhead
| for all result columns received.
|
| DBAPIs that return Decimal natively (e.g. psycopg2) will have
| better accuracy and higher performance with a setting of ``True``,
| as the native translation to Decimal reduces the amount of floating-
| point issues at play, and the Numeric type itself doesn't need
| to apply any further conversions. However, another DBAPI which
| returns floats natively *will* incur an additional conversion
| overhead, and is still subject to floating point data loss - in
| which case ``asdecimal=False`` will at least remove the extra
| conversion overhead.
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Numeric:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.NVARCHAR
Python Library Documentation: class NVARCHAR in module sqlalchemy.sql.sqltypes
class NVARCHAR(Unicode)
| NVARCHAR(length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
|
| The SQL NVARCHAR type.
|
| Method resolution order:
| NVARCHAR
| Unicode
| String
| Concatenable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'NVARCHAR'
|
| ----------------------------------------------------------------------
| Methods inherited from String:
|
| __init__(self, length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
| Create a string-holding type.
|
| :param length: optional, a length for the column for use in
| DDL and CAST expressions. May be safely omitted if no ``CREATE
| TABLE`` will be issued. Certain databases may require a
| ``length`` for use in DDL, and will raise an exception when
| the ``CREATE TABLE`` DDL is issued if a ``VARCHAR``
| with no length is included. Whether the value is
| interpreted as bytes or characters is database specific.
|
| :param collation: Optional, a column-level collation for
| use in DDL and CAST expressions. Renders using the
| COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
| E.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> from sqlalchemy import cast, select, String
| >>> print(select(cast("some string", String(collation="utf8"))))
| {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
|
| .. note::
|
| In most cases, the :class:`.Unicode` or :class:`.UnicodeText`
| datatypes should be used for a :class:`_schema.Column` that expects
| to store non-ascii data. These datatypes will ensure that the
| correct types are used on the database.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from String:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Concatenable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Concatenable:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comparator'>
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comp...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Numeric
Python Library Documentation: class Numeric in module sqlalchemy.sql.sqltypes
class Numeric(HasExpressionLookup, sqlalchemy.sql.type_api.TypeEngine)
| Numeric(precision: 'Optional[int]' = None, scale: 'Optional[int]' = None, decimal_return_scale: 'Optional[int]' = None, asdecimal: 'bool' = True)
|
| Base for non-integer numeric types, such as
| ``NUMERIC``, ``FLOAT``, ``DECIMAL``, and other variants.
|
| The :class:`.Numeric` datatype when used directly will render DDL
| corresponding to precision numerics if available, such as
| ``NUMERIC(precision, scale)``. The :class:`.Float` subclass will
| attempt to render a floating-point datatype such as ``FLOAT(precision)``.
|
| :class:`.Numeric` returns Python ``decimal.Decimal`` objects by default,
| based on the default value of ``True`` for the
| :paramref:`.Numeric.asdecimal` parameter. If this parameter is set to
| False, returned values are coerced to Python ``float`` objects.
|
| The :class:`.Float` subtype, being more specific to floating point,
| defaults the :paramref:`.Float.asdecimal` flag to False so that the
| default Python datatype is ``float``.
|
| .. note::
|
| When using a :class:`.Numeric` datatype against a database type that
| returns Python floating point values to the driver, the accuracy of the
| decimal conversion indicated by :paramref:`.Numeric.asdecimal` may be
| limited. The behavior of specific numeric/floating point datatypes
| is a product of the SQL datatype in use, the Python :term:`DBAPI`
| in use, as well as strategies that may be present within
| the SQLAlchemy dialect in use. Users requiring specific precision/
| scale are encouraged to experiment with the available datatypes
| in order to determine the best results.
|
| Method resolution order:
| Numeric
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, precision: 'Optional[int]' = None, scale: 'Optional[int]' = None, decimal_return_scale: 'Optional[int]' = None, asdecimal: 'bool' = True)
| Construct a Numeric.
|
| :param precision: the numeric precision for use in DDL ``CREATE
| TABLE``.
|
| :param scale: the numeric scale for use in DDL ``CREATE TABLE``.
|
| :param asdecimal: default True. Return whether or not
| values should be sent as Python Decimal objects, or
| as floats. Different DBAPIs send one or the other based on
| datatypes - the Numeric type will ensure that return values
| are one or the other across DBAPIs consistently.
|
| :param decimal_return_scale: Default scale to use when converting
| from floats to Python decimals. Floating point values will typically
| be much longer due to decimal inaccuracy, and most floating point
| database types don't have a notion of "scale", so by default the
| float type looks for the first ten decimal places when converting.
| Specifying this value will override that length. Types which
| do include an explicit ".scale" value, such as the base
| :class:`.Numeric` as well as the MySQL float types, will use the
| value of ".scale" as the default for decimal_return_scale, if not
| otherwise specified.
|
| When using the ``Numeric`` type, care should be taken to ensure
| that the asdecimal setting is appropriate for the DBAPI in use -
| when Numeric applies a conversion from Decimal->float or float->
| Decimal, this conversion incurs an additional performance overhead
| for all result columns received.
|
| DBAPIs that return Decimal natively (e.g. psycopg2) will have
| better accuracy and higher performance with a setting of ``True``,
| as the native translation to Decimal reduces the amount of floating-
| point issues at play, and the Numeric type itself doesn't need
| to apply any further conversions. However, another DBAPI which
| returns floats natively *will* incur an additional conversion
| overhead, and is still subject to floating point data loss - in
| which case ``asdecimal=False`` will at least remove the extra
| conversion overhead.
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'numeric'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.PickleType
Python Library Documentation: class PickleType in module sqlalchemy.sql.sqltypes
class PickleType(sqlalchemy.sql.type_api.TypeDecorator)
| PickleType(protocol: 'int' = 5, pickler: 'Any' = None, comparator: 'Optional[Callable[[Any, Any], bool]]' = None, impl: 'Optional[_TypeEngineArgument[Any]]' = None)
|
| Holds Python objects, which are serialized using pickle.
|
| PickleType builds upon the Binary type to apply Python's
| ``pickle.dumps()`` to incoming objects, and ``pickle.loads()`` on
| the way out, allowing any pickleable Python object to be stored as
| a serialized binary field.
|
| To allow ORM change events to propagate for elements associated
| with :class:`.PickleType`, see :ref:`mutable_toplevel`.
|
| Method resolution order:
| PickleType
| sqlalchemy.sql.type_api.TypeDecorator
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.type_api.ExternalType
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, protocol: 'int' = 5, pickler: 'Any' = None, comparator: 'Optional[Callable[[Any, Any], bool]]' = None, impl: 'Optional[_TypeEngineArgument[Any]]' = None)
| Construct a PickleType.
|
| :param protocol: defaults to ``pickle.HIGHEST_PROTOCOL``.
|
| :param pickler: defaults to pickle. May be any object with
| pickle-compatible ``dumps`` and ``loads`` methods.
|
| :param comparator: a 2-arg callable predicate used
| to compare values of this type. If left as ``None``,
| the Python "equals" operator is used to compare values.
|
| :param impl: A binary-storing :class:`_types.TypeEngine` class or
| instance to use in place of the default :class:`_types.LargeBinary`.
| For example the :class: `_mysql.LONGBLOB` class may be more effective
| when using MySQL.
|
| .. versionadded:: 1.4.20
|
| __reduce__(self)
| Helper for pickle.
|
| bind_processor(self, dialect)
| Provide a bound value processing function for the
| given :class:`.Dialect`.
|
| This is the method that fulfills the :class:`.TypeEngine`
| contract for bound value conversion which normally occurs via
| the :meth:`_types.TypeEngine.bind_processor` method.
|
| .. note::
|
| User-defined subclasses of :class:`_types.TypeDecorator` should
| **not** implement this method, and should instead implement
| :meth:`_types.TypeDecorator.process_bind_param` so that the "inner"
| processing provided by the implementing type is maintained.
|
| :param dialect: Dialect instance in use.
|
| compare_values(self, x, y)
| Given two values, compare them for equality.
|
| By default this calls upon :meth:`.TypeEngine.compare_values`
| of the underlying "impl", which in turn usually
| uses the Python equals operator ``==``.
|
| This function is used by the ORM to compare
| an original-loaded value with an intercepted
| "changed" value, to determine if a net change
| has occurred.
|
| result_processor(self, dialect, coltype)
| Provide a result value processing function for the given
| :class:`.Dialect`.
|
| This is the method that fulfills the :class:`.TypeEngine`
| contract for bound value conversion which normally occurs via
| the :meth:`_types.TypeEngine.result_processor` method.
|
| .. note::
|
| User-defined subclasses of :class:`_types.TypeDecorator` should
| **not** implement this method, and should instead implement
| :meth:`_types.TypeDecorator.process_result_value` so that the
| "inner" processing provided by the implementing type is maintained.
|
| :param dialect: Dialect instance in use.
| :param coltype: A SQLAlchemy data type
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| cache_ok = True
|
| impl = <class 'sqlalchemy.sql.sqltypes.LargeBinary'>
| A type for large binary byte data.
|
| The :class:`.LargeBinary` type corresponds to a large and/or unlengthed
| binary type for the target platform, such as BLOB on MySQL and BYTEA for
| PostgreSQL. It also handles the necessary conversions for the DBAPI.
|
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeDecorator:
|
| __getattr__(self, key: 'str') -> 'Any'
| Proxy all other undefined accessors to the underlying
| implementation.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| bind_expression(self, bindparam: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression which will typically wrap the given parameter.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** necessarily
| called against specific values, and should not be confused with the
| :meth:`_types.TypeDecorator.process_bind_param` method, which is
| the more typical method that processes the actual value passed to a
| particular parameter at statement execution time.
|
| Subclasses of :class:`_types.TypeDecorator` can override this method
| to provide custom bind expression behavior for the type. This
| implementation will **replace** that of the underlying implementation
| type.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'Any'
| Suggest a type for a 'coerced' Python value in an expression.
|
| By default, returns self. This method is called by
| the expression system when an object using this type is
| on the left or right side of an expression against a plain Python
| object which does not yet have a SQLAlchemy type assigned::
|
| expr = table.c.somecolumn + 35
|
| Where above, if ``somecolumn`` uses this type, this method will
| be called with the value ``operator.add``
| and ``35``. The return value is whatever SQLAlchemy type should
| be used for ``35`` for this particular operation.
|
| column_expression(self, column: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a SELECT column expression, return a wrapping SQL expression.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values, and should not be confused with the
| :meth:`_types.TypeDecorator.process_result_value` method, which is
| the more typical method that processes the actual value returned
| in a result row subsequent to statement execution time.
|
| Subclasses of :class:`_types.TypeDecorator` can override this method
| to provide custom column expression behavior for the type. This
| implementation will **replace** that of the underlying implementation
| type.
|
| See the description of :meth:`_types.TypeEngine.column_expression`
| for a complete description of the method's use.
|
| copy(self, **kw: 'Any') -> 'Self'
| Produce a copy of this :class:`.TypeDecorator` instance.
|
| This is a shallow copy and is provided to fulfill part of
| the :class:`.TypeEngine` contract. It usually does not
| need to be overridden unless the user-defined :class:`.TypeDecorator`
| has local state that should be deep-copied.
|
| get_dbapi_type(self, dbapi: 'DBAPIModule') -> 'Optional[Any]'
| Return the DBAPI type object represented by this
| :class:`.TypeDecorator`.
|
| By default this calls upon :meth:`.TypeEngine.get_dbapi_type` of the
| underlying "impl".
|
| impl_instance(...)
|
| literal_processor(self, dialect: 'Dialect') -> 'Optional[_LiteralProcessorType[_T]]'
| Provide a literal processing function for the given
| :class:`.Dialect`.
|
| This is the method that fulfills the :class:`.TypeEngine`
| contract for literal value conversion which normally occurs via
| the :meth:`_types.TypeEngine.literal_processor` method.
|
| .. note::
|
| User-defined subclasses of :class:`_types.TypeDecorator` should
| **not** implement this method, and should instead implement
| :meth:`_types.TypeDecorator.process_literal_param` so that the
| "inner" processing provided by the implementing type is maintained.
|
| load_dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[Any]'
| Return a :class:`.TypeEngine` object corresponding to a dialect.
|
| This is an end-user override hook that can be used to provide
| differing types depending on the given dialect. It is used
| by the :class:`.TypeDecorator` implementation of :meth:`type_engine`
| to help determine what type should ultimately be returned
| for a given :class:`.TypeDecorator`.
|
| By default returns ``self.impl``.
|
| process_bind_param(self, value: 'Optional[_T]', dialect: 'Dialect') -> 'Any'
| Receive a bound parameter value to be converted.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for incoming data values.
| This method is called at **statement execution time** and is passed
| the literal Python data value which is to be associated with a bound
| parameter in the statement.
|
| The operation could be anything desired to perform custom
| behavior, such as transforming or serializing data.
| This could also be used as a hook for validating logic.
|
| :param value: Data to operate upon, of any type expected by
| this method in the subclass. Can be ``None``.
| :param dialect: the :class:`.Dialect` in use.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| :meth:`_types.TypeDecorator.process_result_value`
|
| process_literal_param(self, value: 'Optional[_T]', dialect: 'Dialect') -> 'str'
| Receive a literal parameter value to be rendered inline within
| a statement.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. Unlike other SQL
| compilation methods, it is passed a specific Python value to be
| rendered as a string. However it should not be confused with the
| :meth:`_types.TypeDecorator.process_bind_param` method, which is
| the more typical method that processes the actual value passed to a
| particular parameter at statement execution time.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for incoming data values
| that are in the special case of being rendered as literals.
|
| The returned string will be rendered into the output string.
|
| process_result_value(self, value: 'Optional[Any]', dialect: 'Dialect') -> 'Optional[_T]'
| Receive a result-row column value to be converted.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for data values
| being received in result rows coming from the database.
| This method is called at **result fetching time** and is passed
| the literal Python data value that's extracted from a database result
| row.
|
| The operation could be anything desired to perform custom
| behavior, such as transforming or deserializing data.
|
| :param value: Data to operate upon, of any type expected by
| this method in the subclass. Can be ``None``.
| :param dialect: the :class:`.Dialect` in use.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| :meth:`_types.TypeDecorator.process_bind_param`
|
| type_engine(self, dialect: 'Dialect') -> 'TypeEngine[Any]'
| Return a dialect-specific :class:`.TypeEngine` instance
| for this :class:`.TypeDecorator`.
|
| In most cases this returns a dialect-adapted form of
| the :class:`.TypeEngine` type represented by ``self.impl``.
| Makes usage of :meth:`dialect_impl`.
| Behavior can be customized here by overriding
| :meth:`load_dialect_impl`.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.type_api.TypeDecorator:
|
| comparator_factory
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
| sort_key_function
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeDecorator:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeDecorator.Comparator'...
| A :class:`.TypeEngine.Comparator` that is specific to
| :class:`.TypeDecorator`.
|
| User-defined :class:`.TypeDecorator` classes should not typically
| need to modify this.
|
|
| __visit_name__ = 'type_decorator'
|
| coerce_to_is_types = (<class 'NoneType'>,)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from 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.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.PrimaryKeyConstraint
Python Library Documentation: class PrimaryKeyConstraint in module sqlalchemy.sql.schema
class PrimaryKeyConstraint(ColumnCollectionConstraint)
| PrimaryKeyConstraint(*columns: '_DDLColumnArgument', name: 'Optional[str]' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, info: 'Optional[_InfoType]' = None, _implicit_generated: 'bool' = False, **dialect_kw: 'Any') -> 'None'
|
| A table-level PRIMARY KEY constraint.
|
| The :class:`.PrimaryKeyConstraint` object is present automatically
| on any :class:`_schema.Table` object; it is assigned a set of
| :class:`_schema.Column` objects corresponding to those marked with
| the :paramref:`_schema.Column.primary_key` flag::
|
| >>> my_table = Table(
| ... "mytable",
| ... metadata,
| ... Column("id", Integer, primary_key=True),
| ... Column("version_id", Integer, primary_key=True),
| ... Column("data", String(50)),
| ... )
| >>> my_table.primary_key
| PrimaryKeyConstraint(
| Column('id', Integer(), table=<mytable>,
| primary_key=True, nullable=False),
| Column('version_id', Integer(), table=<mytable>,
| primary_key=True, nullable=False)
| )
|
| The primary key of a :class:`_schema.Table` can also be specified by using
| a :class:`.PrimaryKeyConstraint` object explicitly; in this mode of usage,
| the "name" of the constraint can also be specified, as well as other
| options which may be recognized by dialects::
|
| my_table = Table(
| "mytable",
| metadata,
| Column("id", Integer),
| Column("version_id", Integer),
| Column("data", String(50)),
| PrimaryKeyConstraint("id", "version_id", name="mytable_pk"),
| )
|
| The two styles of column-specification should generally not be mixed.
| An warning is emitted if the columns present in the
| :class:`.PrimaryKeyConstraint`
| don't match the columns that were marked as ``primary_key=True``, if both
| are present; in this case, the columns are taken strictly from the
| :class:`.PrimaryKeyConstraint` declaration, and those columns otherwise
| marked as ``primary_key=True`` are ignored. This behavior is intended to
| be backwards compatible with previous behavior.
|
| For the use case where specific options are to be specified on the
| :class:`.PrimaryKeyConstraint`, but the usual style of using
| ``primary_key=True`` flags is still desirable, an empty
| :class:`.PrimaryKeyConstraint` may be specified, which will take on the
| primary key column collection from the :class:`_schema.Table` based on the
| flags::
|
| my_table = Table(
| "mytable",
| metadata,
| Column("id", Integer, primary_key=True),
| Column("version_id", Integer, primary_key=True),
| Column("data", String(50)),
| PrimaryKeyConstraint(name="mytable_pk", mssql_clustered=True),
| )
|
| Method resolution order:
| PrimaryKeyConstraint
| ColumnCollectionConstraint
| ColumnCollectionMixin
| Constraint
| sqlalchemy.sql.base.DialectKWArgs
| HasConditionalDDL
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __init__(self, *columns: '_DDLColumnArgument', name: 'Optional[str]' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, info: 'Optional[_InfoType]' = None, _implicit_generated: 'bool' = False, **dialect_kw: 'Any') -> 'None'
| :param \*columns:
| A sequence of column names or Column objects.
|
| :param name:
| Optional, the in-database name of this constraint.
|
| :param deferrable:
| Optional bool. If set, emit DEFERRABLE or NOT DEFERRABLE when
| issuing DDL for this constraint.
|
| :param initially:
| Optional string. If set, emit INITIALLY <value> when issuing DDL
| for this constraint.
|
| :param \**dialect_kw: other keyword arguments including
| dialect-specific arguments are propagated to the :class:`.Constraint`
| superclass.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| columns_autoinc_first
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __visit_name__ = 'primary_key_constraint'
|
| ----------------------------------------------------------------------
| Methods inherited from ColumnCollectionConstraint:
|
| __contains__(self, x: 'Any') -> 'bool'
|
| __iter__(self) -> 'Iterator[Column[Any]]'
|
| __len__(self) -> 'int'
|
| contains_column(self, col: 'Column[Any]') -> 'bool'
| Return True if this constraint contains the given column.
|
| Note that this object also contains an attribute ``.columns``
| which is a :class:`_expression.ColumnCollection` of
| :class:`_schema.Column` objects.
|
| copy(self, *, target_table: 'Optional[Table]' = None, **kw: 'Any') -> 'ColumnCollectionConstraint'
| .. deprecated:: 1.4 The :meth:`_schema.ColumnCollectionConstraint.copy` method is deprecated and will be removed in a future release.
|
| ----------------------------------------------------------------------
| Methods inherited from ColumnCollectionMixin:
|
| c(...)
|
| columns(...)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ColumnCollectionMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Constraint:
|
| table
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_options(...)
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| This is a two-level nested registry, keyed to ``<dialect_name>``
| and ``<argument_name>``. For example, the ``postgresql_where``
| argument would be locatable as::
|
| arg = my_object.dialect_options["postgresql"]["where"]
|
| .. versionadded:: 0.9.2
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form
|
| get_dialect_option(self, dialect: 'Dialect', argument_name: 'str', *, else_: 'Any' = None, deprecated_fallback: 'Optional[str]' = None) -> 'Any'
| Return the value of a dialect-specific option, or *else_* if
| this dialect does not register the given argument.
|
| This is useful for DDL compilers that may be inherited by
| third-party dialects whose ``construct_arguments`` do not
| include the same set of keys as the parent dialect.
|
| :param dialect: The dialect for which to retrieve the option.
| :param argument_name: The name of the argument to retrieve.
| :param else\_: The value to return if the argument is not present.
| :param deprecated_fallback: Optional dialect name to fall back to
| if the argument is not present for the current dialect. If the
| argument is present for the fallback dialect but not the current
| dialect, a deprecation warning will be emitted.
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| argument_for(dialect_name: 'str', argument_name: 'str', default: 'Any') -> 'None'
| Add a new kind of dialect-specific keyword argument for this class.
|
| E.g.::
|
| Index.argument_for("mydialect", "length", None)
|
| some_index = Index("a", "b", mydialect_length=5)
|
| The :meth:`.DialectKWArgs.argument_for` method is a per-argument
| way adding extra arguments to the
| :attr:`.DefaultDialect.construct_arguments` dictionary. This
| dictionary provides a list of argument names accepted by various
| schema-level constructs on behalf of a dialect.
|
| New dialects should typically specify this dictionary all at once as a
| data member of the dialect class. The use case for ad-hoc addition of
| argument names is typically for end-user code that is also using
| a custom compilation scheme which consumes the additional arguments.
|
| :param dialect_name: name of a dialect. The dialect must be
| locatable, else a :class:`.NoSuchModuleError` is raised. The
| dialect must also include an existing
| :attr:`.DefaultDialect.construct_arguments` collection, indicating
| that it participates in the keyword-argument validation and default
| system, else :class:`.ArgumentError` is raised. If the dialect does
| not include this collection, then any keyword argument can be
| specified on behalf of this dialect already. All dialects packaged
| within SQLAlchemy include this collection, however for third party
| dialects, support may vary.
|
| :param argument_name: name of the parameter.
|
| :param default: default value of the parameter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_kwargs
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| The arguments are present here in their original ``<dialect>_<kwarg>``
| format. Only arguments that were actually passed are included;
| unlike the :attr:`.DialectKWArgs.dialect_options` collection, which
| contains all options known by this dialect including defaults.
|
| The collection is also writable; keys are accepted of the
| form ``<dialect>_<kwarg>`` where the value will be assembled
| into the list of options.
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_options` - nested dictionary form
|
| kwargs
| A synonym for :attr:`.DialectKWArgs.dialect_kwargs`.
|
| ----------------------------------------------------------------------
| Methods inherited from HasConditionalDDL:
|
| ddl_if(self, dialect: 'Optional[str]' = None, callable_: 'Optional[ddl.DDLIfCallable]' = None, state: 'Optional[Any]' = None) -> 'Self'
| apply a conditional DDL rule to this schema item.
|
| These rules work in a similar manner to the
| :meth:`.ExecutableDDLElement.execute_if` callable, with the added
| feature that the criteria may be checked within the DDL compilation
| phase for a construct such as :class:`.CreateTable`.
| :meth:`.HasConditionalDDL.ddl_if` currently applies towards the
| :class:`.Index` construct as well as all :class:`.Constraint`
| constructs.
|
| :param dialect: string name of a dialect, or a tuple of string names
| to indicate multiple dialect types.
|
| :param callable\_: a callable that is constructed using the same form
| as that described in
| :paramref:`.ExecutableDDLElement.execute_if.callable_`.
|
| :param state: any arbitrary object that will be passed to the
| callable, if present.
|
| .. versionadded:: 2.0
|
| .. seealso::
|
| :ref:`schema_ddl_ddl_if` - background and usage examples
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.QueuePool
Python Library Documentation: class QueuePool in module sqlalchemy.pool.impl
class QueuePool(sqlalchemy.pool.base.Pool)
| QueuePool(creator: 'Union[_CreatorFnType, _CreatorWRecFnType]', pool_size: 'int' = 5, max_overflow: 'int' = 10, timeout: 'float' = 30.0, use_lifo: 'bool' = False, **kw: 'Any')
|
| A :class:`_pool.Pool`
| that imposes a limit on the number of open connections.
|
| :class:`.QueuePool` is the default pooling implementation used for
| all :class:`_engine.Engine` objects other than SQLite with a ``:memory:``
| database.
|
| The :class:`.QueuePool` class **is not compatible** with asyncio and
| :func:`_asyncio.create_async_engine`. The
| :class:`.AsyncAdaptedQueuePool` class is used automatically when
| using :func:`_asyncio.create_async_engine`, if no other kind of pool
| is specified.
|
| .. seealso::
|
| :class:`.AsyncAdaptedQueuePool`
|
| Method resolution order:
| QueuePool
| sqlalchemy.pool.base.Pool
| sqlalchemy.log.Identified
| sqlalchemy.event.registry.EventTarget
| builtins.object
|
| Methods defined here:
|
| __init__(self, creator: 'Union[_CreatorFnType, _CreatorWRecFnType]', pool_size: 'int' = 5, max_overflow: 'int' = 10, timeout: 'float' = 30.0, use_lifo: 'bool' = False, **kw: 'Any')
| Construct a QueuePool.
|
| :param creator: a callable function that returns a DB-API
| connection object, same as that of :paramref:`_pool.Pool.creator`.
|
| :param pool_size: The size of the pool to be maintained,
| defaults to 5. This is the largest number of connections that
| will be kept persistently in the pool. Note that the pool
| begins with no connections; once this number of connections
| is requested, that number of connections will remain.
| ``pool_size`` can be set to 0 to indicate no size limit; to
| disable pooling, use a :class:`~sqlalchemy.pool.NullPool`
| instead.
|
| :param max_overflow: The maximum overflow size of the
| pool. When the number of checked-out connections reaches the
| size set in pool_size, additional connections will be
| returned up to this limit. When those additional connections
| are returned to the pool, they are disconnected and
| discarded. It follows then that the total number of
| simultaneous connections the pool will allow is pool_size +
| `max_overflow`, and the total number of "sleeping"
| connections the pool will allow is pool_size. `max_overflow`
| can be set to -1 to indicate no overflow limit; no limit
| will be placed on the total number of concurrent
| connections. Defaults to 10.
|
| :param timeout: The number of seconds to wait before giving up
| on returning a connection. Defaults to 30.0. This can be a float
| but is subject to the limitations of Python time functions which
| may not be reliable in the tens of milliseconds.
|
| :param use_lifo: use LIFO (last-in-first-out) when retrieving
| connections instead of FIFO (first-in-first-out). Using LIFO, a
| server-side timeout scheme can reduce the number of connections used
| during non-peak periods of use. When planning for server-side
| timeouts, ensure that a recycle or pre-ping strategy is in use to
| gracefully handle stale connections.
|
| .. versionadded:: 1.3
|
| .. seealso::
|
| :ref:`pool_use_lifo`
|
| :ref:`pool_disconnects`
|
| :param \**kw: Other keyword arguments including
| :paramref:`_pool.Pool.recycle`, :paramref:`_pool.Pool.echo`,
| :paramref:`_pool.Pool.reset_on_return` and others are passed to the
| :class:`_pool.Pool` constructor.
|
| checkedin(self) -> 'int'
|
| checkedout(self) -> 'int'
|
| dispose(self) -> 'None'
| Dispose of this pool.
|
| This method leaves the possibility of checked-out connections
| remaining open, as it only affects connections that are
| idle in the pool.
|
| .. seealso::
|
| :meth:`Pool.recreate`
|
| overflow(self) -> 'int'
|
| recreate(self) -> 'QueuePool'
| Return a new :class:`_pool.Pool`, of the same class as this one
| and configured with identical creation arguments.
|
| This method is used in conjunction with :meth:`dispose`
| to close out an entire :class:`_pool.Pool` and create a new one in
| its place.
|
| size(self) -> 'int'
|
| status(self) -> 'str'
| Returns a brief description of the state of this pool.
|
| timeout(self) -> 'float'
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'_pool': 'sqla_queue.QueueCommon[ConnectionPoolEntr...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.pool.base.Pool:
|
| connect(self) -> 'PoolProxiedConnection'
| Return a DBAPI connection from the pool.
|
| The connection is instrumented such that when its
| ``close()`` method is called, the connection will be returned to
| the pool.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.pool.base.Pool:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.pool.base.Pool:
|
| dispatch = <sqlalchemy.event.base.PoolEventsDispatch object>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.log.Identified:
|
| logging_name = None
sqlmodel.REAL
Python Library Documentation: class REAL in module sqlalchemy.sql.sqltypes
class REAL(Float)
| REAL(precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
|
| The SQL REAL type.
|
| .. seealso::
|
| :class:`_types.Float` - documentation for the base type.
|
| Method resolution order:
| REAL
| Float
| Numeric
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'REAL'
|
| ----------------------------------------------------------------------
| Methods inherited from Float:
|
| __init__(self: 'Float[_N]', precision: 'Optional[int]' = None, asdecimal: 'bool' = False, decimal_return_scale: 'Optional[int]' = None)
| Construct a Float.
|
| :param precision: the numeric precision for use in DDL ``CREATE
| TABLE``. Backends **should** attempt to ensure this precision
| indicates a number of digits for the generic
| :class:`_sqltypes.Float` datatype.
|
| .. note:: For the Oracle Database backend, the
| :paramref:`_sqltypes.Float.precision` parameter is not accepted
| when rendering DDL, as Oracle Database does not support float precision
| specified as a number of decimal places. Instead, use the
| Oracle Database-specific :class:`_oracle.FLOAT` datatype and specify the
| :paramref:`_oracle.FLOAT.binary_precision` parameter. This is new
| in version 2.0 of SQLAlchemy.
|
| To create a database agnostic :class:`_types.Float` that
| separately specifies binary precision for Oracle Database, use
| :meth:`_types.TypeEngine.with_variant` as follows::
|
| from sqlalchemy import Column
| from sqlalchemy import Float
| from sqlalchemy.dialects import oracle
|
| Column(
| "float_data",
| Float(5).with_variant(oracle.FLOAT(binary_precision=16), "oracle"),
| )
|
| :param asdecimal: the same flag as that of :class:`.Numeric`, but
| defaults to ``False``. Note that setting this flag to ``True``
| results in floating point conversion.
|
| :param decimal_return_scale: Default scale to use when converting
| from floats to Python decimals. Floating point values will typically
| be much longer due to decimal inaccuracy, and most floating point
| database types don't have a notion of "scale", so by default the
| float type looks for the first ten decimal places when converting.
| Specifying this value will override that length. Note that the
| MySQL float types, which do include "scale", will use "scale"
| as the default for decimal_return_scale, if not otherwise specified.
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Float:
|
| scale = None
|
| ----------------------------------------------------------------------
| Methods inherited from Numeric:
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Numeric:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Relationship
Python Library Documentation: function Relationship in module sqlmodel.main Relationship(*, back_populates: 'str | None' = None, cascade_delete: 'bool | None' = False, passive_deletes: "bool | Literal['all'] | None" = False, link_model: 'Any | None' = None, sa_relationship: 'RelationshipProperty[Any] | None' = None, sa_relationship_args: 'Sequence[Any] | None' = None, sa_relationship_kwargs: 'Mapping[str, Any] | None' = None) -> 'Any'
sqlmodel.SMALLINT
Python Library Documentation: class SMALLINT in module sqlalchemy.sql.sqltypes
class SMALLINT(SmallInteger)
| The SQL SMALLINT type.
|
| .. seealso::
|
| :class:`_types.SmallInteger` - documentation for the base type.
|
| Method resolution order:
| SMALLINT
| SmallInteger
| Integer
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'SMALLINT'
|
| ----------------------------------------------------------------------
| Methods inherited from Integer:
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Integer:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.SQLModel
Python Library Documentation: class SQLModel in module sqlmodel.main
class SQLModel(pydantic.main.BaseModel)
| SQLModel() -> None
|
| Method resolution order:
| SQLModel
| pydantic.main.BaseModel
| builtins.object
|
| Methods defined here:
|
| __init__(__pydantic_self__, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __repr_args__(self) -> 'Sequence[tuple[str | None, Any]]'
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'builtins.dict[str, Any]'
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'builtins.dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
|
| Args:
| mode: The mode in which `to_python` should run.
| If mode is 'json', the output will only contain JSON serializable types.
| If mode is 'python', the output may contain non-JSON-serializable Python objects.
| include: A set of fields to include in the output.
| exclude: A set of fields to exclude from the output.
| context: Additional context to pass to the serializer.
| by_alias: Whether to use the field's alias in the dictionary key if defined.
| exclude_unset: Whether to exclude fields that have not been explicitly set.
| exclude_defaults: Whether to exclude fields that are set to their default value.
| exclude_none: Whether to exclude fields that have a value of `None`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
| warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
| "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| sqlmodel_update(self: '_TSQLModel', obj: 'builtins.dict[str, Any] | BaseModel', *, update: 'builtins.dict[str, Any] | None' = None) -> '_TSQLModel'
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_orm(obj: 'Any', update: 'builtins.dict[str, Any] | None' = None) -> '_TSQLModel'
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, from_attributes: 'bool | None' = None, context: 'builtins.dict[str, Any] | None' = None, update: 'builtins.dict[str, Any] | None' = None) -> '_TSQLModel'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| parse_obj(obj: 'Any', update: 'builtins.dict[str, Any] | None' = None) -> '_TSQLModel'
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, *args: 'Any', **kwargs: 'Any')
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstract__ = True
|
| __abstractmethods__ = frozenset()
|
| __allow_unmapped__ = True
|
| __annotations__ = {'__name__': 'ClassVar[str]', '__sqlmodel_relationsh...
|
| __class_vars__ = {'__name__', '__sqlmodel_relationships__', '__tablena...
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'sqlmodel.main.SQLModel'>, '...
|
| __pydantic_custom_init__ = True
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {}
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = {'__class__': <pydantic._internal._mod...
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="SQLModel", validator=M...
|
| __signature__ = <Signature () -> None>
|
| __sqlmodel_relationships__ = {}
|
| __tablename__ = 'sqlmodel'
|
| __weakref__ = None
|
| metadata = MetaData()
|
| model_config = {'from_attributes': True, 'registry': PydanticUndefined...
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| Args:
| include: Optional set or mapping specifying which fields to include in the copied model.
| exclude: Optional set or mapping specifying which fields to exclude in the copied model.
| update: Optional dictionary of field-value pairs to override field values in the copied model.
| deep: If True, the values of fields that are Pydantic models will be deep-copied.
|
| Returns:
| A copy of the model with included, excluded and updated fields as specified.
|
| json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| Args:
| update: Values to change/add in the new model. Note: the data is not validated
| before creating the new model. You should trust this data.
| deep: Set to `True` to make a deep copy of the model.
|
| Returns:
| New model instance.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| Generates a JSON representation of the model using Pydantic's `to_json` method.
|
| Args:
| indent: Indentation to use in the JSON output. If None is passed, the output will be compact.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| include: Field(s) to include in the JSON output.
| exclude: Field(s) to exclude from the JSON output.
| context: Additional context to pass to the serializer.
| by_alias: Whether to serialize using field aliases.
| exclude_unset: Whether to exclude fields that have not been explicitly set.
| exclude_defaults: Whether to exclude fields that are set to their default value.
| exclude_none: Whether to exclude fields that have a value of `None`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
| warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
| "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| Creates a new instance of the `Model` class with validated data.
|
| Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
| Default values are respected, but no other validation is performed.
|
| !!! note
| `model_construct()` generally respects the `model_config.extra` setting on the provided model.
| That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
| and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
| Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
| an error if extra values are passed, but they will be ignored.
|
| Args:
| _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
| this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
| Otherwise, the field names from the `values` argument will be used.
| values: Trusted or pre-validated data dictionary.
|
| Returns:
| A new instance of the `Model` class with validated data.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| schema_generator: To override the logic used to generate the JSON schema, as a subclass of
| `GenerateJsonSchema` with your desired modifications
| mode: The mode in which to generate the schema.
|
| Returns:
| The JSON schema for the given model class.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate the given object with string data against the Pydantic model.
|
| Args:
| obj: The object containing string data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {}
sqlmodel.Sequence
Python Library Documentation: class Sequence in module sqlalchemy.sql.schema
class Sequence(HasSchemaAttr, IdentityOptions, DefaultGenerator)
| Sequence(name: 'str', start: 'Optional[int]' = None, increment: 'Optional[int]' = None, minvalue: 'Optional[int]' = None, maxvalue: 'Optional[int]' = None, nominvalue: 'Optional[bool]' = None, nomaxvalue: 'Optional[bool]' = None, cycle: 'Optional[bool]' = None, schema: 'Optional[Union[str, Literal[SchemaConst.BLANK_SCHEMA]]]' = None, cache: 'Optional[int]' = None, order: 'Optional[bool]' = None, data_type: 'Optional[_TypeEngineArgument[int]]' = None, optional: 'bool' = False, quote: 'Optional[bool]' = None, metadata: 'Optional[MetaData]' = None, quote_schema: 'Optional[bool]' = None, for_update: 'bool' = False) -> 'None'
|
| Represents a named database sequence.
|
| The :class:`.Sequence` object represents the name and configurational
| parameters of a database sequence. It also represents
| a construct that can be "executed" by a SQLAlchemy :class:`_engine.Engine`
| or :class:`_engine.Connection`,
| rendering the appropriate "next value" function
| for the target database and returning a result.
|
| The :class:`.Sequence` is typically associated with a primary key column::
|
| some_table = Table(
| "some_table",
| metadata,
| Column(
| "id",
| Integer,
| Sequence("some_table_seq", start=1),
| primary_key=True,
| ),
| )
|
| When CREATE TABLE is emitted for the above :class:`_schema.Table`, if the
| target platform supports sequences, a CREATE SEQUENCE statement will
| be emitted as well. For platforms that don't support sequences,
| the :class:`.Sequence` construct is ignored.
|
| .. seealso::
|
| :ref:`defaults_sequences`
|
| :class:`.CreateSequence`
|
| :class:`.DropSequence`
|
| Method resolution order:
| Sequence
| HasSchemaAttr
| IdentityOptions
| DefaultGenerator
| sqlalchemy.sql.base.Executable
| sqlalchemy.sql.roles.StatementRole
| sqlalchemy.sql.roles.SQLRole
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Methods defined here:
|
| __init__(self, name: 'str', start: 'Optional[int]' = None, increment: 'Optional[int]' = None, minvalue: 'Optional[int]' = None, maxvalue: 'Optional[int]' = None, nominvalue: 'Optional[bool]' = None, nomaxvalue: 'Optional[bool]' = None, cycle: 'Optional[bool]' = None, schema: 'Optional[Union[str, Literal[SchemaConst.BLANK_SCHEMA]]]' = None, cache: 'Optional[int]' = None, order: 'Optional[bool]' = None, data_type: 'Optional[_TypeEngineArgument[int]]' = None, optional: 'bool' = False, quote: 'Optional[bool]' = None, metadata: 'Optional[MetaData]' = None, quote_schema: 'Optional[bool]' = None, for_update: 'bool' = False) -> 'None'
| Construct a :class:`.Sequence` object.
|
| :param name: the name of the sequence.
|
| :param start: the starting index of the sequence. This value is
| used when the CREATE SEQUENCE command is emitted to the database
| as the value of the "START WITH" clause. If ``None``, the
| clause is omitted, which on most platforms indicates a starting
| value of 1.
|
| .. versionchanged:: 2.0 The :paramref:`.Sequence.start` parameter
| is required in order to have DDL emit "START WITH". This is a
| reversal of a change made in version 1.4 which would implicitly
| render "START WITH 1" if the :paramref:`.Sequence.start` were
| not included. See :ref:`change_7211` for more detail.
|
| :param increment: the increment value of the sequence. This
| value is used when the CREATE SEQUENCE command is emitted to
| the database as the value of the "INCREMENT BY" clause. If ``None``,
| the clause is omitted, which on most platforms indicates an
| increment of 1.
| :param minvalue: the minimum value of the sequence. This
| value is used when the CREATE SEQUENCE command is emitted to
| the database as the value of the "MINVALUE" clause. If ``None``,
| the clause is omitted, which on most platforms indicates a
| minvalue of 1 and -2^63-1 for ascending and descending sequences,
| respectively.
|
| :param maxvalue: the maximum value of the sequence. This
| value is used when the CREATE SEQUENCE command is emitted to
| the database as the value of the "MAXVALUE" clause. If ``None``,
| the clause is omitted, which on most platforms indicates a
| maxvalue of 2^63-1 and -1 for ascending and descending sequences,
| respectively.
|
| :param nominvalue: no minimum value of the sequence. This
| value is used when the CREATE SEQUENCE command is emitted to
| the database as the value of the "NO MINVALUE" clause. If ``None``,
| the clause is omitted, which on most platforms indicates a
| minvalue of 1 and -2^63-1 for ascending and descending sequences,
| respectively.
|
| :param nomaxvalue: no maximum value of the sequence. This
| value is used when the CREATE SEQUENCE command is emitted to
| the database as the value of the "NO MAXVALUE" clause. If ``None``,
| the clause is omitted, which on most platforms indicates a
| maxvalue of 2^63-1 and -1 for ascending and descending sequences,
| respectively.
|
| :param cycle: allows the sequence to wrap around when the maxvalue
| or minvalue has been reached by an ascending or descending sequence
| respectively. This value is used when the CREATE SEQUENCE command
| is emitted to the database as the "CYCLE" clause. If the limit is
| reached, the next number generated will be the minvalue or maxvalue,
| respectively. If cycle=False (the default) any calls to nextval
| after the sequence has reached its maximum value will return an
| error.
|
| :param schema: optional schema name for the sequence, if located
| in a schema other than the default. The rules for selecting the
| schema name when a :class:`_schema.MetaData`
| is also present are the same
| as that of :paramref:`_schema.Table.schema`.
|
| :param cache: optional integer value; number of future values in the
| sequence which are calculated in advance. Renders the CACHE keyword
| understood by Oracle Database and PostgreSQL.
|
| :param order: optional boolean value; if ``True``, renders the
| ORDER keyword, understood by Oracle Database, indicating the sequence
| is definitively ordered. May be necessary to provide deterministic
| ordering using Oracle RAC.
|
| :param data_type: The type to be returned by the sequence, for
| dialects that allow us to choose between INTEGER, BIGINT, etc.
| (e.g., mssql).
|
| .. versionadded:: 1.4.0
|
| :param optional: boolean value, when ``True``, indicates that this
| :class:`.Sequence` object only needs to be explicitly generated
| on backends that don't provide another way to generate primary
| key identifiers. Currently, it essentially means, "don't create
| this sequence on the PostgreSQL backend, where the SERIAL keyword
| creates a sequence for us automatically".
| :param quote: boolean value, when ``True`` or ``False``, explicitly
| forces quoting of the :paramref:`_schema.Sequence.name` on or off.
| When left at its default of ``None``, normal quoting rules based
| on casing and reserved words take place.
| :param quote_schema: Set the quoting preferences for the ``schema``
| name.
|
| :param metadata: optional :class:`_schema.MetaData` object which this
| :class:`.Sequence` will be associated with. A :class:`.Sequence`
| that is associated with a :class:`_schema.MetaData`
| gains the following
| capabilities:
|
| * The :class:`.Sequence` will inherit the
| :paramref:`_schema.MetaData.schema`
| parameter specified to the target :class:`_schema.MetaData`, which
| affects the production of CREATE / DROP DDL, if any.
|
| * The :meth:`.Sequence.create` and :meth:`.Sequence.drop` methods
| automatically use the engine bound to the :class:`_schema.MetaData`
| object, if any.
|
| * The :meth:`_schema.MetaData.create_all` and
| :meth:`_schema.MetaData.drop_all`
| methods will emit CREATE / DROP for this :class:`.Sequence`,
| even if the :class:`.Sequence` is not associated with any
| :class:`_schema.Table` / :class:`_schema.Column`
| that's a member of this
| :class:`_schema.MetaData`.
|
| The above behaviors can only occur if the :class:`.Sequence` is
| explicitly associated with the :class:`_schema.MetaData`
| via this parameter.
|
| .. seealso::
|
| :ref:`sequence_metadata` - full discussion of the
| :paramref:`.Sequence.metadata` parameter.
|
| :param for_update: Indicates this :class:`.Sequence`, when associated
| with a :class:`_schema.Column`,
| should be invoked for UPDATE statements
| on that column's table, rather than for INSERT statements, when
| no value is otherwise present for that column in the statement.
|
| create(self, bind: '_CreateDropBind', checkfirst: 'bool' = True) -> 'None'
| Creates this sequence in the database.
|
| drop(self, bind: '_CreateDropBind', checkfirst: 'bool' = True) -> 'None'
| Drops this sequence from the database.
|
| next_value(self) -> 'Function[int]'
| Return a :class:`.next_value` function element
| which will render the appropriate increment function
| for this :class:`.Sequence` within any SQL expression.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'column': 'Optional[Column[Any]]', 'data_type': 'Op...
|
| __visit_name__ = 'sequence'
|
| is_sequence = True
|
| ----------------------------------------------------------------------
| Data descriptors inherited from IdentityOptions:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from DefaultGenerator:
|
| has_arg = False
|
| is_callable = False
|
| is_clause_element = False
|
| is_identity = False
|
| is_scalar = False
|
| is_sentinel = False
|
| is_server_default = False
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.Executable:
|
| execution_options(self, **kw: 'Any') -> 'Self'
| Set non-SQL options for the statement which take effect during
| execution.
|
| Execution options can be set at many scopes, including per-statement,
| per-connection, or per execution, using methods such as
| :meth:`_engine.Connection.execution_options` and parameters which
| accept a dictionary of options such as
| :paramref:`_engine.Connection.execute.execution_options` and
| :paramref:`_orm.Session.execute.execution_options`.
|
| The primary characteristic of an execution option, as opposed to
| other kinds of options such as ORM loader options, is that
| **execution options never affect the compiled SQL of a query, only
| things that affect how the SQL statement itself is invoked or how
| results are fetched**. That is, execution options are not part of
| what's accommodated by SQL compilation nor are they considered part of
| the cached state of a statement.
|
| The :meth:`_sql.Executable.execution_options` method is
| :term:`generative`, as
| is the case for the method as applied to the :class:`_engine.Engine`
| and :class:`_orm.Query` objects, which means when the method is called,
| a copy of the object is returned, which applies the given parameters to
| that new copy, but leaves the original unchanged::
|
| statement = select(table.c.x, table.c.y)
| new_statement = statement.execution_options(my_option=True)
|
| An exception to this behavior is the :class:`_engine.Connection`
| object, where the :meth:`_engine.Connection.execution_options` method
| is explicitly **not** generative.
|
| The kinds of options that may be passed to
| :meth:`_sql.Executable.execution_options` and other related methods and
| parameter dictionaries include parameters that are explicitly consumed
| by SQLAlchemy Core or ORM, as well as arbitrary keyword arguments not
| defined by SQLAlchemy, which means the methods and/or parameter
| dictionaries may be used for user-defined parameters that interact with
| custom code, which may access the parameters using methods such as
| :meth:`_sql.Executable.get_execution_options` and
| :meth:`_engine.Connection.get_execution_options`, or within selected
| event hooks using a dedicated ``execution_options`` event parameter
| such as
| :paramref:`_events.ConnectionEvents.before_execute.execution_options`
| or :attr:`_orm.ORMExecuteState.execution_options`, e.g.::
|
| from sqlalchemy import event
|
|
| @event.listens_for(some_engine, "before_execute")
| def _process_opt(conn, statement, multiparams, params, execution_options):
| "run a SQL function before invoking a statement"
|
| if execution_options.get("do_special_thing", False):
| conn.exec_driver_sql("run_special_function()")
|
| Within the scope of options that are explicitly recognized by
| SQLAlchemy, most apply to specific classes of objects and not others.
| The most common execution options include:
|
| * :paramref:`_engine.Connection.execution_options.isolation_level` -
| sets the isolation level for a connection or a class of connections
| via an :class:`_engine.Engine`. This option is accepted only
| by :class:`_engine.Connection` or :class:`_engine.Engine`.
|
| * :paramref:`_engine.Connection.execution_options.stream_results` -
| indicates results should be fetched using a server side cursor;
| this option is accepted by :class:`_engine.Connection`, by the
| :paramref:`_engine.Connection.execute.execution_options` parameter
| on :meth:`_engine.Connection.execute`, and additionally by
| :meth:`_sql.Executable.execution_options` on a SQL statement object,
| as well as by ORM constructs like :meth:`_orm.Session.execute`.
|
| * :paramref:`_engine.Connection.execution_options.compiled_cache` -
| indicates a dictionary that will serve as the
| :ref:`SQL compilation cache <sql_caching>`
| for a :class:`_engine.Connection` or :class:`_engine.Engine`, as
| well as for ORM methods like :meth:`_orm.Session.execute`.
| Can be passed as ``None`` to disable caching for statements.
| This option is not accepted by
| :meth:`_sql.Executable.execution_options` as it is inadvisable to
| carry along a compilation cache within a statement object.
|
| * :paramref:`_engine.Connection.execution_options.schema_translate_map`
| - a mapping of schema names used by the
| :ref:`Schema Translate Map <schema_translating>` feature, accepted
| by :class:`_engine.Connection`, :class:`_engine.Engine`,
| :class:`_sql.Executable`, as well as by ORM constructs
| like :meth:`_orm.Session.execute`.
|
| .. seealso::
|
| :meth:`_engine.Connection.execution_options`
|
| :paramref:`_engine.Connection.execute.execution_options`
|
| :paramref:`_orm.Session.execute.execution_options`
|
| :ref:`orm_queryguide_execution_options` - documentation on all
| ORM-specific execution options
|
| get_execution_options(self) -> '_ExecuteOptions'
| Get the non-SQL options which will take effect during execution.
|
| .. versionadded:: 1.3
|
| .. seealso::
|
| :meth:`.Executable.execution_options`
|
| options(self, *options: 'ExecutableOption') -> 'Self'
| Apply options to this statement.
|
| In the general sense, options are any kind of Python object
| that can be interpreted by the SQL compiler for the statement.
| These options can be consumed by specific dialects or specific kinds
| of compilers.
|
| The most commonly known kind of option are the ORM level options
| that apply "eager load" and other loading behaviors to an ORM
| query. However, options can theoretically be used for many other
| purposes.
|
| For background on specific kinds of options for specific kinds of
| statements, refer to the documentation for those option objects.
|
| .. versionchanged:: 1.4 - added :meth:`.Executable.options` to
| Core statement objects towards the goal of allowing unified
| Core / ORM querying capabilities.
|
| .. seealso::
|
| :ref:`loading_columns` - refers to options specific to the usage
| of ORM queries
|
| :ref:`relationship_loader_options` - refers to options specific
| to the usage of ORM queries
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.Executable:
|
| is_delete = False
|
| is_dml = False
|
| is_from_statement = False
|
| is_insert = False
|
| is_select = False
|
| is_text = False
|
| is_update = False
|
| supports_execution = True
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.roles.SQLRole:
|
| allows_lambda = False
|
| uses_inspection = False
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Session
Python Library Documentation: class Session in module sqlmodel.orm.session
class Session(sqlalchemy.orm.session.Session)
| Session(bind: 'Optional[_SessionBind]' = None, *, autoflush: 'bool' = True, future: 'Literal[True]' = True, expire_on_commit: 'bool' = True, autobegin: 'bool' = True, twophase: 'bool' = False, binds: 'Optional[Dict[_SessionBindKey, _SessionBind]]' = None, enable_baked_queries: 'bool' = True, info: 'Optional[_InfoType]' = None, query_cls: 'Optional[Type[Query[Any]]]' = None, autocommit: 'Literal[False]' = False, join_transaction_mode: 'JoinTransactionMode' = 'conditional_savepoint', close_resets_only: 'Union[bool, _NoArg]' = _NoArg.NO_ARG)
|
| Method resolution order:
| Session
| sqlalchemy.orm.session.Session
| sqlalchemy.orm.session._SessionClassMethods
| sqlalchemy.event.registry.EventTarget
| builtins.object
|
| Methods defined here:
|
| exec(self, statement: Union[sqlmodel.sql._expression_select_cls.Select, sqlmodel.sql._expression_select_cls.SelectOfScalar, sqlmodel.sql.base.Executable[~_TSelectParam], sqlalchemy.sql.dml.UpdateBase], *, params: collections.abc.Mapping[str, typing.Any] | collections.abc.Sequence[collections.abc.Mapping[str, typing.Any]] | None = None, execution_options: collections.abc.Mapping[str, typing.Any] = immutabledict({}), bind_arguments: dict[str, typing.Any] | None = None, _parent_execute_state: typing.Any | None = None, _add_event: typing.Any | None = None) -> Union[sqlalchemy.engine.result.TupleResult[~_TSelectParam], sqlalchemy.engine.result.ScalarResult[~_TSelectParam], sqlalchemy.engine.cursor.CursorResult[Any]]
|
| execute(self, statement: sqlalchemy.sql.base.Executable, params: Union[Sequence[Mapping[str, Any]], Mapping[str, Any], NoneType] = None, *, execution_options: Union[sqlalchemy.orm._typing._OrmKnownExecutionOptions, Mapping[str, Any]] = immutabledict({}), bind_arguments: dict[str, typing.Any] | None = None, _parent_execute_state: typing.Any | None = None, _add_event: typing.Any | None = None) -> sqlalchemy.engine.result.Result[typing.Any]
| 🚨 You probably want to use `session.exec()` instead of `session.execute()`.
|
| This is the original SQLAlchemy `session.execute()` method that returns objects
| of type `Row`, and that you have to call `scalars()` to get the model objects.
|
| For example:
|
| ```Python
| heroes = session.execute(select(Hero)).scalars().all()
| ```
|
| instead you could use `exec()`:
|
| ```Python
| heroes = session.exec(select(Hero)).all()
| ```
|
| query(self, *entities: Union[sqlalchemy.sql.roles.TypedColumnsClauseRole[Any], sqlalchemy.sql.roles.ColumnsClauseRole, ForwardRef('SQLCoreOperations[_T]'), Literal['*', 1], Type[Any], sqlalchemy.inspection.Inspectable[sqlalchemy.sql._typing._HasClauseElement[Any]], sqlalchemy.sql._typing._HasClauseElement[Any]], **kwargs: Any) -> sqlalchemy.orm.query.Query
| 🚨 You probably want to use `session.exec()` instead of `session.query()`.
|
| `session.exec()` is SQLModel's own short version with increased type
| annotations.
|
| Or otherwise you might want to use `session.execute()` instead of
| `session.query()`.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.orm.session.Session:
|
| __contains__(self, instance: 'object') -> 'bool'
| Return True if the instance is associated with this session.
|
| The instance may be pending or persistent within the Session for a
| result of True.
|
| __enter__(self: '_S') -> '_S'
|
| __exit__(self, type_: 'Any', value: 'Any', traceback: 'Any') -> 'None'
|
| __init__(self, bind: 'Optional[_SessionBind]' = None, *, autoflush: 'bool' = True, future: 'Literal[True]' = True, expire_on_commit: 'bool' = True, autobegin: 'bool' = True, twophase: 'bool' = False, binds: 'Optional[Dict[_SessionBindKey, _SessionBind]]' = None, enable_baked_queries: 'bool' = True, info: 'Optional[_InfoType]' = None, query_cls: 'Optional[Type[Query[Any]]]' = None, autocommit: 'Literal[False]' = False, join_transaction_mode: 'JoinTransactionMode' = 'conditional_savepoint', close_resets_only: 'Union[bool, _NoArg]' = _NoArg.NO_ARG)
| Construct a new :class:`_orm.Session`.
|
| See also the :class:`.sessionmaker` function which is used to
| generate a :class:`.Session`-producing callable with a given
| set of arguments.
|
| :param autoflush: When ``True``, all query operations will issue a
| :meth:`~.Session.flush` call to this ``Session`` before proceeding.
| This is a convenience feature so that :meth:`~.Session.flush` need
| not be called repeatedly in order for database queries to retrieve
| results.
|
| .. seealso::
|
| :ref:`session_flushing` - additional background on autoflush
|
| :param autobegin: Automatically start transactions (i.e. equivalent to
| invoking :meth:`_orm.Session.begin`) when database access is
| requested by an operation. Defaults to ``True``. Set to
| ``False`` to prevent a :class:`_orm.Session` from implicitly
| beginning transactions after construction, as well as after any of
| the :meth:`_orm.Session.rollback`, :meth:`_orm.Session.commit`,
| or :meth:`_orm.Session.close` methods are called.
|
| .. versionadded:: 2.0
|
| .. seealso::
|
| :ref:`session_autobegin_disable`
|
| :param bind: An optional :class:`_engine.Engine` or
| :class:`_engine.Connection` to
| which this ``Session`` should be bound. When specified, all SQL
| operations performed by this session will execute via this
| connectable.
|
| :param binds: A dictionary which may specify any number of
| :class:`_engine.Engine` or :class:`_engine.Connection`
| objects as the source of
| connectivity for SQL operations on a per-entity basis. The keys
| of the dictionary consist of any series of mapped classes,
| arbitrary Python classes that are bases for mapped classes,
| :class:`_schema.Table` objects and :class:`_orm.Mapper` objects.
| The
| values of the dictionary are then instances of
| :class:`_engine.Engine`
| or less commonly :class:`_engine.Connection` objects.
| Operations which
| proceed relative to a particular mapped class will consult this
| dictionary for the closest matching entity in order to determine
| which :class:`_engine.Engine` should be used for a particular SQL
| operation. The complete heuristics for resolution are
| described at :meth:`.Session.get_bind`. Usage looks like::
|
| Session = sessionmaker(
| binds={
| SomeMappedClass: create_engine("postgresql+psycopg2://engine1"),
| SomeDeclarativeBase: create_engine(
| "postgresql+psycopg2://engine2"
| ),
| some_mapper: create_engine("postgresql+psycopg2://engine3"),
| some_table: create_engine("postgresql+psycopg2://engine4"),
| }
| )
|
| .. seealso::
|
| :ref:`session_partitioning`
|
| :meth:`.Session.bind_mapper`
|
| :meth:`.Session.bind_table`
|
| :meth:`.Session.get_bind`
|
|
| :param \class_: Specify an alternate class other than
| ``sqlalchemy.orm.session.Session`` which should be used by the
| returned class. This is the only argument that is local to the
| :class:`.sessionmaker` function, and is not sent directly to the
| constructor for ``Session``.
|
| :param enable_baked_queries: legacy; defaults to ``True``.
| A parameter consumed
| by the :mod:`sqlalchemy.ext.baked` extension to determine if
| "baked queries" should be cached, as is the normal operation
| of this extension. When set to ``False``, caching as used by
| this particular extension is disabled.
|
| .. versionchanged:: 1.4 The ``sqlalchemy.ext.baked`` extension is
| legacy and is not used by any of SQLAlchemy's internals. This
| flag therefore only affects applications that are making explicit
| use of this extension within their own code.
|
| :param expire_on_commit: Defaults to ``True``. When ``True``, all
| instances will be fully expired after each :meth:`~.commit`,
| so that all attribute/object access subsequent to a completed
| transaction will load from the most recent database state.
|
| .. seealso::
|
| :ref:`session_committing`
|
| :param future: Deprecated; this flag is always True.
|
| .. seealso::
|
| :ref:`migration_20_toplevel`
|
| :param info: optional dictionary of arbitrary data to be associated
| with this :class:`.Session`. Is available via the
| :attr:`.Session.info` attribute. Note the dictionary is copied at
| construction time so that modifications to the per-
| :class:`.Session` dictionary will be local to that
| :class:`.Session`.
|
| :param query_cls: Class which should be used to create new Query
| objects, as returned by the :meth:`~.Session.query` method.
| Defaults to :class:`_query.Query`.
|
| :param twophase: When ``True``, all transactions will be started as
| a "two phase" transaction, i.e. using the "two phase" semantics
| of the database in use along with an XID. During a
| :meth:`~.commit`, after :meth:`~.flush` has been issued for all
| attached databases, the :meth:`~.TwoPhaseTransaction.prepare`
| method on each database's :class:`.TwoPhaseTransaction` will be
| called. This allows each database to roll back the entire
| transaction, before each transaction is committed.
|
| :param autocommit: the "autocommit" keyword is present for backwards
| compatibility but must remain at its default value of ``False``.
|
| :param join_transaction_mode: Describes the transactional behavior to
| take when a given bind is a :class:`_engine.Connection` that
| has already begun a transaction outside the scope of this
| :class:`_orm.Session`; in other words the
| :meth:`_engine.Connection.in_transaction()` method returns True.
|
| The following behaviors only take effect when the :class:`_orm.Session`
| **actually makes use of the connection given**; that is, a method
| such as :meth:`_orm.Session.execute`, :meth:`_orm.Session.connection`,
| etc. are actually invoked:
|
| * ``"conditional_savepoint"`` - this is the default. if the given
| :class:`_engine.Connection` is begun within a transaction but
| does not have a SAVEPOINT, then ``"rollback_only"`` is used.
| If the :class:`_engine.Connection` is additionally within
| a SAVEPOINT, in other words
| :meth:`_engine.Connection.in_nested_transaction()` method returns
| True, then ``"create_savepoint"`` is used.
|
| ``"conditional_savepoint"`` behavior attempts to make use of
| savepoints in order to keep the state of the existing transaction
| unchanged, but only if there is already a savepoint in progress;
| otherwise, it is not assumed that the backend in use has adequate
| support for SAVEPOINT, as availability of this feature varies.
| ``"conditional_savepoint"`` also seeks to establish approximate
| backwards compatibility with previous :class:`_orm.Session`
| behavior, for applications that are not setting a specific mode. It
| is recommended that one of the explicit settings be used.
|
| * ``"create_savepoint"`` - the :class:`_orm.Session` will use
| :meth:`_engine.Connection.begin_nested()` in all cases to create
| its own transaction. This transaction by its nature rides
| "on top" of any existing transaction that's opened on the given
| :class:`_engine.Connection`; if the underlying database and
| the driver in use has full, non-broken support for SAVEPOINT, the
| external transaction will remain unaffected throughout the
| lifespan of the :class:`_orm.Session`.
|
| The ``"create_savepoint"`` mode is the most useful for integrating
| a :class:`_orm.Session` into a test suite where an externally
| initiated transaction should remain unaffected; however, it relies
| on proper SAVEPOINT support from the underlying driver and
| database.
|
| .. tip:: When using SQLite, the SQLite driver included through
| Python 3.11 does not handle SAVEPOINTs correctly in all cases
| without workarounds. See the sections
| :ref:`pysqlite_serializable` and :ref:`aiosqlite_serializable`
| for details on current workarounds.
|
| * ``"control_fully"`` - the :class:`_orm.Session` will take
| control of the given transaction as its own;
| :meth:`_orm.Session.commit` will call ``.commit()`` on the
| transaction, :meth:`_orm.Session.rollback` will call
| ``.rollback()`` on the transaction, :meth:`_orm.Session.close` will
| call ``.rollback`` on the transaction.
|
| .. tip:: This mode of use is equivalent to how SQLAlchemy 1.4 would
| handle a :class:`_engine.Connection` given with an existing
| SAVEPOINT (i.e. :meth:`_engine.Connection.begin_nested`); the
| :class:`_orm.Session` would take full control of the existing
| SAVEPOINT.
|
| * ``"rollback_only"`` - the :class:`_orm.Session` will take control
| of the given transaction for ``.rollback()`` calls only;
| ``.commit()`` calls will not be propagated to the given
| transaction. ``.close()`` calls will have no effect on the
| given transaction.
|
| .. tip:: This mode of use is equivalent to how SQLAlchemy 1.4 would
| handle a :class:`_engine.Connection` given with an existing
| regular database transaction (i.e.
| :meth:`_engine.Connection.begin`); the :class:`_orm.Session`
| would propagate :meth:`_orm.Session.rollback` calls to the
| underlying transaction, but not :meth:`_orm.Session.commit` or
| :meth:`_orm.Session.close` calls.
|
| .. versionadded:: 2.0.0rc1
|
| :param close_resets_only: Defaults to ``True``. Determines if
| the session should reset itself after calling ``.close()``
| or should pass in a no longer usable state, disabling reuse.
|
| .. versionadded:: 2.0.22 added flag ``close_resets_only``.
| A future SQLAlchemy version may change the default value of
| this flag to ``False``.
|
| .. seealso::
|
| :ref:`session_closing` - Detail on the semantics of
| :meth:`_orm.Session.close` and :meth:`_orm.Session.reset`.
|
| __iter__(self) -> 'Iterator[object]'
| Iterate over all pending or persistent instances within this
| Session.
|
| add(self, instance: 'object', _warn: 'bool' = True) -> 'None'
| Place an object into this :class:`_orm.Session`.
|
| Objects that are in the :term:`transient` state when passed to the
| :meth:`_orm.Session.add` method will move to the
| :term:`pending` state, until the next flush, at which point they
| will move to the :term:`persistent` state.
|
| Objects that are in the :term:`detached` state when passed to the
| :meth:`_orm.Session.add` method will move to the :term:`persistent`
| state directly.
|
| If the transaction used by the :class:`_orm.Session` is rolled back,
| objects which were transient when they were passed to
| :meth:`_orm.Session.add` will be moved back to the
| :term:`transient` state, and will no longer be present within this
| :class:`_orm.Session`.
|
| .. seealso::
|
| :meth:`_orm.Session.add_all`
|
| :ref:`session_adding` - at :ref:`session_basics`
|
| add_all(self, instances: 'Iterable[object]') -> 'None'
| Add the given collection of instances to this :class:`_orm.Session`.
|
| See the documentation for :meth:`_orm.Session.add` for a general
| behavioral description.
|
| .. seealso::
|
| :meth:`_orm.Session.add`
|
| :ref:`session_adding` - at :ref:`session_basics`
|
| begin(self, nested: 'bool' = False) -> 'SessionTransaction'
| Begin a transaction, or nested transaction,
| on this :class:`.Session`, if one is not already begun.
|
| The :class:`_orm.Session` object features **autobegin** behavior,
| so that normally it is not necessary to call the
| :meth:`_orm.Session.begin`
| method explicitly. However, it may be used in order to control
| the scope of when the transactional state is begun.
|
| When used to begin the outermost transaction, an error is raised
| if this :class:`.Session` is already inside of a transaction.
|
| :param nested: if True, begins a SAVEPOINT transaction and is
| equivalent to calling :meth:`~.Session.begin_nested`. For
| documentation on SAVEPOINT transactions, please see
| :ref:`session_begin_nested`.
|
| :return: the :class:`.SessionTransaction` object. Note that
| :class:`.SessionTransaction`
| acts as a Python context manager, allowing :meth:`.Session.begin`
| to be used in a "with" block. See :ref:`session_explicit_begin` for
| an example.
|
| .. seealso::
|
| :ref:`session_autobegin`
|
| :ref:`unitofwork_transaction`
|
| :meth:`.Session.begin_nested`
|
| begin_nested(self) -> 'SessionTransaction'
| Begin a "nested" transaction on this Session, e.g. SAVEPOINT.
|
| The target database(s) and associated drivers must support SQL
| SAVEPOINT for this method to function correctly.
|
| For documentation on SAVEPOINT
| transactions, please see :ref:`session_begin_nested`.
|
| :return: the :class:`.SessionTransaction` object. Note that
| :class:`.SessionTransaction` acts as a context manager, allowing
| :meth:`.Session.begin_nested` to be used in a "with" block.
| See :ref:`session_begin_nested` for a usage example.
|
| .. seealso::
|
| :ref:`session_begin_nested`
|
| :ref:`pysqlite_serializable` - special workarounds required
| with the SQLite driver in order for SAVEPOINT to work
| correctly. For asyncio use cases, see the section
| :ref:`aiosqlite_serializable`.
|
| bind_mapper(self, mapper: '_EntityBindKey[_O]', bind: '_SessionBind') -> 'None'
| Associate a :class:`_orm.Mapper` or arbitrary Python class with a
| "bind", e.g. an :class:`_engine.Engine` or
| :class:`_engine.Connection`.
|
| The given entity is added to a lookup used by the
| :meth:`.Session.get_bind` method.
|
| :param mapper: a :class:`_orm.Mapper` object,
| or an instance of a mapped
| class, or any Python class that is the base of a set of mapped
| classes.
|
| :param bind: an :class:`_engine.Engine` or :class:`_engine.Connection`
| object.
|
| .. seealso::
|
| :ref:`session_partitioning`
|
| :paramref:`.Session.binds`
|
| :meth:`.Session.bind_table`
|
| bind_table(self, table: 'TableClause', bind: '_SessionBind') -> 'None'
| Associate a :class:`_schema.Table` with a "bind", e.g. an
| :class:`_engine.Engine`
| or :class:`_engine.Connection`.
|
| The given :class:`_schema.Table` is added to a lookup used by the
| :meth:`.Session.get_bind` method.
|
| :param table: a :class:`_schema.Table` object,
| which is typically the target
| of an ORM mapping, or is present within a selectable that is
| mapped.
|
| :param bind: an :class:`_engine.Engine` or :class:`_engine.Connection`
| object.
|
| .. seealso::
|
| :ref:`session_partitioning`
|
| :paramref:`.Session.binds`
|
| :meth:`.Session.bind_mapper`
|
| bulk_insert_mappings(self, mapper: '_EntityBindKey[Any]', mappings: 'Iterable[Dict[str, Any]]', return_defaults: 'bool' = False, render_nulls: 'bool' = False) -> 'None'
| Perform a bulk insert of the given list of mapping dictionaries.
|
| .. legacy::
|
| This method is a legacy feature as of the 2.0 series of
| SQLAlchemy. For modern bulk INSERT and UPDATE, see
| the sections :ref:`orm_queryguide_bulk_insert` and
| :ref:`orm_queryguide_bulk_update`. The 2.0 API shares
| implementation details with this method and adds new features
| as well.
|
| :param mapper: a mapped class, or the actual :class:`_orm.Mapper`
| object,
| representing the single kind of object represented within the mapping
| list.
|
| :param mappings: a sequence of dictionaries, each one containing the
| state of the mapped row to be inserted, in terms of the attribute
| names on the mapped class. If the mapping refers to multiple tables,
| such as a joined-inheritance mapping, each dictionary must contain all
| keys to be populated into all tables.
|
| :param return_defaults: when True, the INSERT process will be altered
| to ensure that newly generated primary key values will be fetched.
| The rationale for this parameter is typically to enable
| :ref:`Joined Table Inheritance <joined_inheritance>` mappings to
| be bulk inserted.
|
| .. note:: for backends that don't support RETURNING, the
| :paramref:`_orm.Session.bulk_insert_mappings.return_defaults`
| parameter can significantly decrease performance as INSERT
| statements can no longer be batched. See
| :ref:`engine_insertmanyvalues`
| for background on which backends are affected.
|
| :param render_nulls: When True, a value of ``None`` will result
| in a NULL value being included in the INSERT statement, rather
| than the column being omitted from the INSERT. This allows all
| the rows being INSERTed to have the identical set of columns which
| allows the full set of rows to be batched to the DBAPI. Normally,
| each column-set that contains a different combination of NULL values
| than the previous row must omit a different series of columns from
| the rendered INSERT statement, which means it must be emitted as a
| separate statement. By passing this flag, the full set of rows
| are guaranteed to be batchable into one batch; the cost however is
| that server-side defaults which are invoked by an omitted column will
| be skipped, so care must be taken to ensure that these are not
| necessary.
|
| .. warning::
|
| When this flag is set, **server side default SQL values will
| not be invoked** for those columns that are inserted as NULL;
| the NULL value will be sent explicitly. Care must be taken
| to ensure that no server-side default functions need to be
| invoked for the operation as a whole.
|
| .. seealso::
|
| :doc:`queryguide/dml`
|
| :meth:`.Session.bulk_save_objects`
|
| :meth:`.Session.bulk_update_mappings`
|
| bulk_save_objects(self, objects: 'Iterable[object]', return_defaults: 'bool' = False, update_changed_only: 'bool' = True, preserve_order: 'bool' = True) -> 'None'
| Perform a bulk save of the given list of objects.
|
| .. legacy::
|
| This method is a legacy feature as of the 2.0 series of
| SQLAlchemy. For modern bulk INSERT and UPDATE, see
| the sections :ref:`orm_queryguide_bulk_insert` and
| :ref:`orm_queryguide_bulk_update`.
|
| For general INSERT and UPDATE of existing ORM mapped objects,
| prefer standard :term:`unit of work` data management patterns,
| introduced in the :ref:`unified_tutorial` at
| :ref:`tutorial_orm_data_manipulation`. SQLAlchemy 2.0
| now uses :ref:`engine_insertmanyvalues` with modern dialects
| which solves previous issues of bulk INSERT slowness.
|
| :param objects: a sequence of mapped object instances. The mapped
| objects are persisted as is, and are **not** associated with the
| :class:`.Session` afterwards.
|
| For each object, whether the object is sent as an INSERT or an
| UPDATE is dependent on the same rules used by the :class:`.Session`
| in traditional operation; if the object has the
| :attr:`.InstanceState.key`
| attribute set, then the object is assumed to be "detached" and
| will result in an UPDATE. Otherwise, an INSERT is used.
|
| In the case of an UPDATE, statements are grouped based on which
| attributes have changed, and are thus to be the subject of each
| SET clause. If ``update_changed_only`` is False, then all
| attributes present within each object are applied to the UPDATE
| statement, which may help in allowing the statements to be grouped
| together into a larger executemany(), and will also reduce the
| overhead of checking history on attributes.
|
| :param return_defaults: when True, rows that are missing values which
| generate defaults, namely integer primary key defaults and sequences,
| will be inserted **one at a time**, so that the primary key value
| is available. In particular this will allow joined-inheritance
| and other multi-table mappings to insert correctly without the need
| to provide primary key values ahead of time; however,
| :paramref:`.Session.bulk_save_objects.return_defaults` **greatly
| reduces the performance gains** of the method overall. It is strongly
| advised to please use the standard :meth:`_orm.Session.add_all`
| approach.
|
| :param update_changed_only: when True, UPDATE statements are rendered
| based on those attributes in each state that have logged changes.
| When False, all attributes present are rendered into the SET clause
| with the exception of primary key attributes.
|
| :param preserve_order: when True, the order of inserts and updates
| matches exactly the order in which the objects are given. When
| False, common types of objects are grouped into inserts
| and updates, to allow for more batching opportunities.
|
| .. seealso::
|
| :doc:`queryguide/dml`
|
| :meth:`.Session.bulk_insert_mappings`
|
| :meth:`.Session.bulk_update_mappings`
|
| bulk_update_mappings(self, mapper: '_EntityBindKey[Any]', mappings: 'Iterable[Dict[str, Any]]') -> 'None'
| Perform a bulk update of the given list of mapping dictionaries.
|
| .. legacy::
|
| This method is a legacy feature as of the 2.0 series of
| SQLAlchemy. For modern bulk INSERT and UPDATE, see
| the sections :ref:`orm_queryguide_bulk_insert` and
| :ref:`orm_queryguide_bulk_update`. The 2.0 API shares
| implementation details with this method and adds new features
| as well.
|
| :param mapper: a mapped class, or the actual :class:`_orm.Mapper`
| object,
| representing the single kind of object represented within the mapping
| list.
|
| :param mappings: a sequence of dictionaries, each one containing the
| state of the mapped row to be updated, in terms of the attribute names
| on the mapped class. If the mapping refers to multiple tables, such
| as a joined-inheritance mapping, each dictionary may contain keys
| corresponding to all tables. All those keys which are present and
| are not part of the primary key are applied to the SET clause of the
| UPDATE statement; the primary key values, which are required, are
| applied to the WHERE clause.
|
|
| .. seealso::
|
| :doc:`queryguide/dml`
|
| :meth:`.Session.bulk_insert_mappings`
|
| :meth:`.Session.bulk_save_objects`
|
| close(self) -> 'None'
| Close out the transactional resources and ORM objects used by this
| :class:`_orm.Session`.
|
| This expunges all ORM objects associated with this
| :class:`_orm.Session`, ends any transaction in progress and
| :term:`releases` any :class:`_engine.Connection` objects which this
| :class:`_orm.Session` itself has checked out from associated
| :class:`_engine.Engine` objects. The operation then leaves the
| :class:`_orm.Session` in a state which it may be used again.
|
| .. tip::
|
| In the default running mode the :meth:`_orm.Session.close`
| method **does not prevent the Session from being used again**.
| The :class:`_orm.Session` itself does not actually have a
| distinct "closed" state; it merely means
| the :class:`_orm.Session` will release all database connections
| and ORM objects.
|
| Setting the parameter :paramref:`_orm.Session.close_resets_only`
| to ``False`` will instead make the ``close`` final, meaning that
| any further action on the session will be forbidden.
|
| .. versionchanged:: 1.4 The :meth:`.Session.close` method does not
| immediately create a new :class:`.SessionTransaction` object;
| instead, the new :class:`.SessionTransaction` is created only if
| the :class:`.Session` is used again for a database operation.
|
| .. seealso::
|
| :ref:`session_closing` - detail on the semantics of
| :meth:`_orm.Session.close` and :meth:`_orm.Session.reset`.
|
| :meth:`_orm.Session.reset` - a similar method that behaves like
| ``close()`` with the parameter
| :paramref:`_orm.Session.close_resets_only` set to ``True``.
|
| commit(self) -> 'None'
| Flush pending changes and commit the current transaction.
|
| When the COMMIT operation is complete, all objects are fully
| :term:`expired`, erasing their internal contents, which will be
| automatically re-loaded when the objects are next accessed. In the
| interim, these objects are in an expired state and will not function if
| they are :term:`detached` from the :class:`.Session`. Additionally,
| this re-load operation is not supported when using asyncio-oriented
| APIs. The :paramref:`.Session.expire_on_commit` parameter may be used
| to disable this behavior.
|
| When there is no transaction in place for the :class:`.Session`,
| indicating that no operations were invoked on this :class:`.Session`
| since the previous call to :meth:`.Session.commit`, the method will
| begin and commit an internal-only "logical" transaction, that does not
| normally affect the database unless pending flush changes were
| detected, but will still invoke event handlers and object expiration
| rules.
|
| The outermost database transaction is committed unconditionally,
| automatically releasing any SAVEPOINTs in effect.
|
| .. seealso::
|
| :ref:`session_committing`
|
| :ref:`unitofwork_transaction`
|
| :ref:`asyncio_orm_avoid_lazyloads`
|
| connection(self, bind_arguments: 'Optional[_BindArguments]' = None, execution_options: 'Optional[CoreExecuteOptionsParameter]' = None) -> 'Connection'
| Return a :class:`_engine.Connection` object corresponding to this
| :class:`.Session` object's transactional state.
|
| Either the :class:`_engine.Connection` corresponding to the current
| transaction is returned, or if no transaction is in progress, a new
| one is begun and the :class:`_engine.Connection`
| returned (note that no
| transactional state is established with the DBAPI until the first
| SQL statement is emitted).
|
| Ambiguity in multi-bind or unbound :class:`.Session` objects can be
| resolved through any of the optional keyword arguments. This
| ultimately makes usage of the :meth:`.get_bind` method for resolution.
|
| :param bind_arguments: dictionary of bind arguments. May include
| "mapper", "bind", "clause", other custom arguments that are passed
| to :meth:`.Session.get_bind`.
|
| :param execution_options: a dictionary of execution options that will
| be passed to :meth:`_engine.Connection.execution_options`, **when the
| connection is first procured only**. If the connection is already
| present within the :class:`.Session`, a warning is emitted and
| the arguments are ignored.
|
| .. seealso::
|
| :ref:`session_transaction_isolation`
|
| delete(self, instance: 'object') -> 'None'
| Mark an instance as deleted.
|
| The object is assumed to be either :term:`persistent` or
| :term:`detached` when passed; after the method is called, the
| object will remain in the :term:`persistent` state until the next
| flush proceeds. During this time, the object will also be a member
| of the :attr:`_orm.Session.deleted` collection.
|
| When the next flush proceeds, the object will move to the
| :term:`deleted` state, indicating a ``DELETE`` statement was emitted
| for its row within the current transaction. When the transaction
| is successfully committed,
| the deleted object is moved to the :term:`detached` state and is
| no longer present within this :class:`_orm.Session`.
|
| .. seealso::
|
| :ref:`session_deleting` - at :ref:`session_basics`
|
| enable_relationship_loading(self, obj: 'object') -> 'None'
| Associate an object with this :class:`.Session` for related
| object loading.
|
| .. warning::
|
| :meth:`.enable_relationship_loading` exists to serve special
| use cases and is not recommended for general use.
|
| Accesses of attributes mapped with :func:`_orm.relationship`
| will attempt to load a value from the database using this
| :class:`.Session` as the source of connectivity. The values
| will be loaded based on foreign key and primary key values
| present on this object - if not present, then those relationships
| will be unavailable.
|
| The object will be attached to this session, but will
| **not** participate in any persistence operations; its state
| for almost all purposes will remain either "transient" or
| "detached", except for the case of relationship loading.
|
| Also note that backrefs will often not work as expected.
| Altering a relationship-bound attribute on the target object
| may not fire off a backref event, if the effective value
| is what was already loaded from a foreign-key-holding value.
|
| The :meth:`.Session.enable_relationship_loading` method is
| similar to the ``load_on_pending`` flag on :func:`_orm.relationship`.
| Unlike that flag, :meth:`.Session.enable_relationship_loading` allows
| an object to remain transient while still being able to load
| related items.
|
| To make a transient object associated with a :class:`.Session`
| via :meth:`.Session.enable_relationship_loading` pending, add
| it to the :class:`.Session` using :meth:`.Session.add` normally.
| If the object instead represents an existing identity in the database,
| it should be merged using :meth:`.Session.merge`.
|
| :meth:`.Session.enable_relationship_loading` does not improve
| behavior when the ORM is used normally - object references should be
| constructed at the object level, not at the foreign key level, so
| that they are present in an ordinary way before flush()
| proceeds. This method is not intended for general use.
|
| .. seealso::
|
| :paramref:`_orm.relationship.load_on_pending` - this flag
| allows per-relationship loading of many-to-ones on items that
| are pending.
|
| :func:`.make_transient_to_detached` - allows for an object to
| be added to a :class:`.Session` without SQL emitted, which then
| will unexpire attributes on access.
|
| expire(self, instance: 'object', attribute_names: 'Optional[Iterable[str]]' = None) -> 'None'
| Expire the attributes on an instance.
|
| Marks the attributes of an instance as out of date. When an expired
| attribute is next accessed, a query will be issued to the
| :class:`.Session` object's current transactional context in order to
| load all expired attributes for the given instance. Note that
| a highly isolated transaction will return the same values as were
| previously read in that same transaction, regardless of changes
| in database state outside of that transaction.
|
| To expire all objects in the :class:`.Session` simultaneously,
| use :meth:`Session.expire_all`.
|
| The :class:`.Session` object's default behavior is to
| expire all state whenever the :meth:`Session.rollback`
| or :meth:`Session.commit` methods are called, so that new
| state can be loaded for the new transaction. For this reason,
| calling :meth:`Session.expire` only makes sense for the specific
| case that a non-ORM SQL statement was emitted in the current
| transaction.
|
| :param instance: The instance to be refreshed.
| :param attribute_names: optional list of string attribute names
| indicating a subset of attributes to be expired.
|
| .. seealso::
|
| :ref:`session_expire` - introductory material
|
| :meth:`.Session.expire`
|
| :meth:`.Session.refresh`
|
| :meth:`_orm.Query.populate_existing`
|
| expire_all(self) -> 'None'
| Expires all persistent instances within this Session.
|
| When any attributes on a persistent instance is next accessed,
| a query will be issued using the
| :class:`.Session` object's current transactional context in order to
| load all expired attributes for the given instance. Note that
| a highly isolated transaction will return the same values as were
| previously read in that same transaction, regardless of changes
| in database state outside of that transaction.
|
| To expire individual objects and individual attributes
| on those objects, use :meth:`Session.expire`.
|
| The :class:`.Session` object's default behavior is to
| expire all state whenever the :meth:`Session.rollback`
| or :meth:`Session.commit` methods are called, so that new
| state can be loaded for the new transaction. For this reason,
| calling :meth:`Session.expire_all` is not usually needed,
| assuming the transaction is isolated.
|
| .. seealso::
|
| :ref:`session_expire` - introductory material
|
| :meth:`.Session.expire`
|
| :meth:`.Session.refresh`
|
| :meth:`_orm.Query.populate_existing`
|
| expunge(self, instance: 'object') -> 'None'
| Remove the `instance` from this ``Session``.
|
| This will free all internal references to the instance. Cascading
| will be applied according to the *expunge* cascade rule.
|
| expunge_all(self) -> 'None'
| Remove all object instances from this ``Session``.
|
| This is equivalent to calling ``expunge(obj)`` on all objects in this
| ``Session``.
|
| flush(self, objects: 'Optional[Sequence[Any]]' = None) -> 'None'
| Flush all the object changes to the database.
|
| Writes out all pending object creations, deletions and modifications
| to the database as INSERTs, DELETEs, UPDATEs, etc. Operations are
| automatically ordered by the Session's unit of work dependency
| solver.
|
| Database operations will be issued in the current transactional
| context and do not affect the state of the transaction, unless an
| error occurs, in which case the entire transaction is rolled back.
| You may flush() as often as you like within a transaction to move
| changes from Python to the database's transaction buffer.
|
| :param objects: Optional; restricts the flush operation to operate
| only on elements that are in the given collection.
|
| This feature is for an extremely narrow set of use cases where
| particular objects may need to be operated upon before the
| full flush() occurs. It is not intended for general use.
|
| get(self, entity: '_EntityBindKey[_O]', ident: '_PKIdentityArgument', *, options: 'Optional[Sequence[ORMOption]]' = None, populate_existing: 'bool' = False, with_for_update: 'ForUpdateParameter' = None, identity_token: 'Optional[Any]' = None, execution_options: 'OrmExecuteOptionsParameter' = immutabledict({}), bind_arguments: 'Optional[_BindArguments]' = None) -> 'Optional[_O]'
| Return an instance based on the given primary key identifier,
| or ``None`` if not found.
|
| E.g.::
|
| my_user = session.get(User, 5)
|
| some_object = session.get(VersionedFoo, (5, 10))
|
| some_object = session.get(VersionedFoo, {"id": 5, "version_id": 10})
|
| .. versionadded:: 1.4 Added :meth:`_orm.Session.get`, which is moved
| from the now legacy :meth:`_orm.Query.get` method.
|
| :meth:`_orm.Session.get` is special in that it provides direct
| access to the identity map of the :class:`.Session`.
| If the given primary key identifier is present
| in the local identity map, the object is returned
| directly from this collection and no SQL is emitted,
| unless the object has been marked fully expired.
| If not present,
| a SELECT is performed in order to locate the object.
|
| :meth:`_orm.Session.get` also will perform a check if
| the object is present in the identity map and
| marked as expired - a SELECT
| is emitted to refresh the object as well as to
| ensure that the row is still present.
| If not, :class:`~sqlalchemy.orm.exc.ObjectDeletedError` is raised.
|
| :param entity: a mapped class or :class:`.Mapper` indicating the
| type of entity to be loaded.
|
| :param ident: A scalar, tuple, or dictionary representing the
| primary key. For a composite (e.g. multiple column) primary key,
| a tuple or dictionary should be passed.
|
| For a single-column primary key, the scalar calling form is typically
| the most expedient. If the primary key of a row is the value "5",
| the call looks like::
|
| my_object = session.get(SomeClass, 5)
|
| The tuple form contains primary key values typically in
| the order in which they correspond to the mapped
| :class:`_schema.Table`
| object's primary key columns, or if the
| :paramref:`_orm.Mapper.primary_key` configuration parameter were
| used, in
| the order used for that parameter. For example, if the primary key
| of a row is represented by the integer
| digits "5, 10" the call would look like::
|
| my_object = session.get(SomeClass, (5, 10))
|
| The dictionary form should include as keys the mapped attribute names
| corresponding to each element of the primary key. If the mapped class
| has the attributes ``id``, ``version_id`` as the attributes which
| store the object's primary key value, the call would look like::
|
| my_object = session.get(SomeClass, {"id": 5, "version_id": 10})
|
| :param options: optional sequence of loader options which will be
| applied to the query, if one is emitted.
|
| :param populate_existing: causes the method to unconditionally emit
| a SQL query and refresh the object with the newly loaded data,
| regardless of whether or not the object is already present.
|
| :param with_for_update: optional boolean ``True`` indicating FOR UPDATE
| should be used, or may be a dictionary containing flags to
| indicate a more specific set of FOR UPDATE flags for the SELECT;
| flags should match the parameters of
| :meth:`_query.Query.with_for_update`.
| Supersedes the :paramref:`.Session.refresh.lockmode` parameter.
|
| :param execution_options: optional dictionary of execution options,
| which will be associated with the query execution if one is emitted.
| This dictionary can provide a subset of the options that are
| accepted by :meth:`_engine.Connection.execution_options`, and may
| also provide additional options understood only in an ORM context.
|
| .. versionadded:: 1.4.29
|
| .. seealso::
|
| :ref:`orm_queryguide_execution_options` - ORM-specific execution
| options
|
| :param bind_arguments: dictionary of additional arguments to determine
| the bind. May include "mapper", "bind", or other custom arguments.
| Contents of this dictionary are passed to the
| :meth:`.Session.get_bind` method.
|
| .. versionadded: 2.0.0rc1
|
| :return: The object instance, or ``None``.
|
| get_bind(self, mapper: 'Optional[_EntityBindKey[_O]]' = None, *, clause: 'Optional[ClauseElement]' = None, bind: 'Optional[_SessionBind]' = None, _sa_skip_events: 'Optional[bool]' = None, _sa_skip_for_implicit_returning: 'bool' = False, **kw: 'Any') -> 'Union[Engine, Connection]'
| Return a "bind" to which this :class:`.Session` is bound.
|
| The "bind" is usually an instance of :class:`_engine.Engine`,
| except in the case where the :class:`.Session` has been
| explicitly bound directly to a :class:`_engine.Connection`.
|
| For a multiply-bound or unbound :class:`.Session`, the
| ``mapper`` or ``clause`` arguments are used to determine the
| appropriate bind to return.
|
| Note that the "mapper" argument is usually present
| when :meth:`.Session.get_bind` is called via an ORM
| operation such as a :meth:`.Session.query`, each
| individual INSERT/UPDATE/DELETE operation within a
| :meth:`.Session.flush`, call, etc.
|
| The order of resolution is:
|
| 1. if mapper given and :paramref:`.Session.binds` is present,
| locate a bind based first on the mapper in use, then
| on the mapped class in use, then on any base classes that are
| present in the ``__mro__`` of the mapped class, from more specific
| superclasses to more general.
| 2. if clause given and ``Session.binds`` is present,
| locate a bind based on :class:`_schema.Table` objects
| found in the given clause present in ``Session.binds``.
| 3. if ``Session.binds`` is present, return that.
| 4. if clause given, attempt to return a bind
| linked to the :class:`_schema.MetaData` ultimately
| associated with the clause.
| 5. if mapper given, attempt to return a bind
| linked to the :class:`_schema.MetaData` ultimately
| associated with the :class:`_schema.Table` or other
| selectable to which the mapper is mapped.
| 6. No bind can be found, :exc:`~sqlalchemy.exc.UnboundExecutionError`
| is raised.
|
| Note that the :meth:`.Session.get_bind` method can be overridden on
| a user-defined subclass of :class:`.Session` to provide any kind
| of bind resolution scheme. See the example at
| :ref:`session_custom_partitioning`.
|
| :param mapper:
| Optional mapped class or corresponding :class:`_orm.Mapper` instance.
| The bind can be derived from a :class:`_orm.Mapper` first by
| consulting the "binds" map associated with this :class:`.Session`,
| and secondly by consulting the :class:`_schema.MetaData` associated
| with the :class:`_schema.Table` to which the :class:`_orm.Mapper` is
| mapped for a bind.
|
| :param clause:
| A :class:`_expression.ClauseElement` (i.e.
| :func:`_expression.select`,
| :func:`_expression.text`,
| etc.). If the ``mapper`` argument is not present or could not
| produce a bind, the given expression construct will be searched
| for a bound element, typically a :class:`_schema.Table`
| associated with
| bound :class:`_schema.MetaData`.
|
| .. seealso::
|
| :ref:`session_partitioning`
|
| :paramref:`.Session.binds`
|
| :meth:`.Session.bind_mapper`
|
| :meth:`.Session.bind_table`
|
| get_nested_transaction(self) -> 'Optional[SessionTransaction]'
| Return the current nested transaction in progress, if any.
|
| .. versionadded:: 1.4
|
| get_one(self, entity: '_EntityBindKey[_O]', ident: '_PKIdentityArgument', *, options: 'Optional[Sequence[ORMOption]]' = None, populate_existing: 'bool' = False, with_for_update: 'ForUpdateParameter' = None, identity_token: 'Optional[Any]' = None, execution_options: 'OrmExecuteOptionsParameter' = immutabledict({}), bind_arguments: 'Optional[_BindArguments]' = None) -> '_O'
| Return exactly one instance based on the given primary key
| identifier, or raise an exception if not found.
|
| Raises :class:`_exc.NoResultFound` if the query selects no rows.
|
| For a detailed documentation of the arguments see the
| method :meth:`.Session.get`.
|
| .. versionadded:: 2.0.22
|
| :return: The object instance.
|
| .. seealso::
|
| :meth:`.Session.get` - equivalent method that instead
| returns ``None`` if no row was found with the provided primary
| key
|
| get_transaction(self) -> 'Optional[SessionTransaction]'
| Return the current root transaction in progress, if any.
|
| .. versionadded:: 1.4
|
| in_nested_transaction(self) -> 'bool'
| Return True if this :class:`_orm.Session` has begun a nested
| transaction, e.g. SAVEPOINT.
|
| .. versionadded:: 1.4
|
| in_transaction(self) -> 'bool'
| Return True if this :class:`_orm.Session` has begun a transaction.
|
| .. versionadded:: 1.4
|
| .. seealso::
|
| :attr:`_orm.Session.is_active`
|
| info(...)
| A user-modifiable dictionary.
|
| The initial value of this dictionary can be populated using the
| ``info`` argument to the :class:`.Session` constructor or
| :class:`.sessionmaker` constructor or factory methods. The dictionary
| here is always local to this :class:`.Session` and can be modified
| independently of all other :class:`.Session` objects.
|
| invalidate(self) -> 'None'
| Close this Session, using connection invalidation.
|
| This is a variant of :meth:`.Session.close` that will additionally
| ensure that the :meth:`_engine.Connection.invalidate`
| method will be called on each :class:`_engine.Connection` object
| that is currently in use for a transaction (typically there is only
| one connection unless the :class:`_orm.Session` is used with
| multiple engines).
|
| This can be called when the database is known to be in a state where
| the connections are no longer safe to be used.
|
| Below illustrates a scenario when using `gevent
| <https://www.gevent.org/>`_, which can produce ``Timeout`` exceptions
| that may mean the underlying connection should be discarded::
|
| import gevent
|
| try:
| sess = Session()
| sess.add(User())
| sess.commit()
| except gevent.Timeout:
| sess.invalidate()
| raise
| except:
| sess.rollback()
| raise
|
| The method additionally does everything that :meth:`_orm.Session.close`
| does, including that all ORM objects are expunged.
|
| is_modified(self, instance: 'object', include_collections: 'bool' = True) -> 'bool'
| Return ``True`` if the given instance has locally
| modified attributes.
|
| This method retrieves the history for each instrumented
| attribute on the instance and performs a comparison of the current
| value to its previously flushed or committed value, if any.
|
| It is in effect a more expensive and accurate
| version of checking for the given instance in the
| :attr:`.Session.dirty` collection; a full test for
| each attribute's net "dirty" status is performed.
|
| E.g.::
|
| return session.is_modified(someobject)
|
| A few caveats to this method apply:
|
| * Instances present in the :attr:`.Session.dirty` collection may
| report ``False`` when tested with this method. This is because
| the object may have received change events via attribute mutation,
| thus placing it in :attr:`.Session.dirty`, but ultimately the state
| is the same as that loaded from the database, resulting in no net
| change here.
| * Scalar attributes may not have recorded the previously set
| value when a new value was applied, if the attribute was not loaded,
| or was expired, at the time the new value was received - in these
| cases, the attribute is assumed to have a change, even if there is
| ultimately no net change against its database value. SQLAlchemy in
| most cases does not need the "old" value when a set event occurs, so
| it skips the expense of a SQL call if the old value isn't present,
| based on the assumption that an UPDATE of the scalar value is
| usually needed, and in those few cases where it isn't, is less
| expensive on average than issuing a defensive SELECT.
|
| The "old" value is fetched unconditionally upon set only if the
| attribute container has the ``active_history`` flag set to ``True``.
| This flag is set typically for primary key attributes and scalar
| object references that are not a simple many-to-one. To set this
| flag for any arbitrary mapped column, use the ``active_history``
| argument with :func:`.column_property`.
|
| :param instance: mapped instance to be tested for pending changes.
| :param include_collections: Indicates if multivalued collections
| should be included in the operation. Setting this to ``False`` is a
| way to detect only local-column based properties (i.e. scalar columns
| or many-to-one foreign keys) that would result in an UPDATE for this
| instance upon flush.
|
| merge(self, instance: '_O', *, load: 'bool' = True, options: 'Optional[Sequence[ORMOption]]' = None) -> '_O'
| Copy the state of a given instance into a corresponding instance
| within this :class:`.Session`.
|
| :meth:`.Session.merge` examines the primary key attributes of the
| source instance, and attempts to reconcile it with an instance of the
| same primary key in the session. If not found locally, it attempts
| to load the object from the database based on primary key, and if
| none can be located, creates a new instance. The state of each
| attribute on the source instance is then copied to the target
| instance. The resulting target instance is then returned by the
| method; the original source instance is left unmodified, and
| un-associated with the :class:`.Session` if not already.
|
| This operation cascades to associated instances if the association is
| mapped with ``cascade="merge"``.
|
| See :ref:`unitofwork_merging` for a detailed discussion of merging.
|
| :param instance: Instance to be merged.
| :param load: Boolean, when False, :meth:`.merge` switches into
| a "high performance" mode which causes it to forego emitting history
| events as well as all database access. This flag is used for
| cases such as transferring graphs of objects into a :class:`.Session`
| from a second level cache, or to transfer just-loaded objects
| into the :class:`.Session` owned by a worker thread or process
| without re-querying the database.
|
| The ``load=False`` use case adds the caveat that the given
| object has to be in a "clean" state, that is, has no pending changes
| to be flushed - even if the incoming object is detached from any
| :class:`.Session`. This is so that when
| the merge operation populates local attributes and
| cascades to related objects and
| collections, the values can be "stamped" onto the
| target object as is, without generating any history or attribute
| events, and without the need to reconcile the incoming data with
| any existing related objects or collections that might not
| be loaded. The resulting objects from ``load=False`` are always
| produced as "clean", so it is only appropriate that the given objects
| should be "clean" as well, else this suggests a mis-use of the
| method.
| :param options: optional sequence of loader options which will be
| applied to the :meth:`_orm.Session.get` method when the merge
| operation loads the existing version of the object from the database.
|
| .. versionadded:: 1.4.24
|
|
| .. seealso::
|
| :func:`.make_transient_to_detached` - provides for an alternative
| means of "merging" a single object into the :class:`.Session`
|
| no_autoflush(...)
| Return a context manager that disables autoflush.
|
| e.g.::
|
| with session.no_autoflush:
|
| some_object = SomeClass()
| session.add(some_object)
| # won't autoflush
| some_object.related_thing = session.query(SomeRelated).first()
|
| Operations that proceed within the ``with:`` block
| will not be subject to flushes occurring upon query
| access. This is useful when initializing a series
| of objects which involve existing database queries,
| where the uncompleted object should not yet be flushed.
|
| prepare(self) -> 'None'
| Prepare the current transaction in progress for two phase commit.
|
| If no transaction is in progress, this method raises an
| :exc:`~sqlalchemy.exc.InvalidRequestError`.
|
| Only root transactions of two phase sessions can be prepared. If the
| current transaction is not such, an
| :exc:`~sqlalchemy.exc.InvalidRequestError` is raised.
|
| refresh(self, instance: 'object', attribute_names: 'Optional[Iterable[str]]' = None, with_for_update: 'ForUpdateParameter' = None) -> 'None'
| Expire and refresh attributes on the given instance.
|
| The selected attributes will first be expired as they would when using
| :meth:`_orm.Session.expire`; then a SELECT statement will be issued to
| the database to refresh column-oriented attributes with the current
| value available in the current transaction.
|
| :func:`_orm.relationship` oriented attributes will also be immediately
| loaded if they were already eagerly loaded on the object, using the
| same eager loading strategy that they were loaded with originally.
|
| .. versionadded:: 1.4 - the :meth:`_orm.Session.refresh` method
| can also refresh eagerly loaded attributes.
|
| :func:`_orm.relationship` oriented attributes that would normally
| load using the ``select`` (or "lazy") loader strategy will also
| load **if they are named explicitly in the attribute_names
| collection**, emitting a SELECT statement for the attribute using the
| ``immediate`` loader strategy. If lazy-loaded relationships are not
| named in :paramref:`_orm.Session.refresh.attribute_names`, then
| they remain as "lazy loaded" attributes and are not implicitly
| refreshed.
|
| .. versionchanged:: 2.0.4 The :meth:`_orm.Session.refresh` method
| will now refresh lazy-loaded :func:`_orm.relationship` oriented
| attributes for those which are named explicitly in the
| :paramref:`_orm.Session.refresh.attribute_names` collection.
|
| .. tip::
|
| While the :meth:`_orm.Session.refresh` method is capable of
| refreshing both column and relationship oriented attributes, its
| primary focus is on refreshing of local column-oriented attributes
| on a single instance. For more open ended "refresh" functionality,
| including the ability to refresh the attributes on many objects at
| once while having explicit control over relationship loader
| strategies, use the
| :ref:`populate existing <orm_queryguide_populate_existing>` feature
| instead.
|
| Note that a highly isolated transaction will return the same values as
| were previously read in that same transaction, regardless of changes
| in database state outside of that transaction. Refreshing
| attributes usually only makes sense at the start of a transaction
| where database rows have not yet been accessed.
|
| :param attribute_names: optional. An iterable collection of
| string attribute names indicating a subset of attributes to
| be refreshed.
|
| :param with_for_update: optional boolean ``True`` indicating FOR UPDATE
| should be used, or may be a dictionary containing flags to
| indicate a more specific set of FOR UPDATE flags for the SELECT;
| flags should match the parameters of
| :meth:`_query.Query.with_for_update`.
| Supersedes the :paramref:`.Session.refresh.lockmode` parameter.
|
| .. seealso::
|
| :ref:`session_expire` - introductory material
|
| :meth:`.Session.expire`
|
| :meth:`.Session.expire_all`
|
| :ref:`orm_queryguide_populate_existing` - allows any ORM query
| to refresh objects as they would be loaded normally.
|
| reset(self) -> 'None'
| Close out the transactional resources and ORM objects used by this
| :class:`_orm.Session`, resetting the session to its initial state.
|
| This method provides for same "reset-only" behavior that the
| :meth:`_orm.Session.close` method has provided historically, where the
| state of the :class:`_orm.Session` is reset as though the object were
| brand new, and ready to be used again.
| This method may then be useful for :class:`_orm.Session` objects
| which set :paramref:`_orm.Session.close_resets_only` to ``False``,
| so that "reset only" behavior is still available.
|
| .. versionadded:: 2.0.22
|
| .. seealso::
|
| :ref:`session_closing` - detail on the semantics of
| :meth:`_orm.Session.close` and :meth:`_orm.Session.reset`.
|
| :meth:`_orm.Session.close` - a similar method will additionally
| prevent reuse of the Session when the parameter
| :paramref:`_orm.Session.close_resets_only` is set to ``False``.
|
| rollback(self) -> 'None'
| Rollback the current transaction in progress.
|
| If no transaction is in progress, this method is a pass-through.
|
| The method always rolls back
| the topmost database transaction, discarding any nested
| transactions that may be in progress.
|
| .. seealso::
|
| :ref:`session_rollback`
|
| :ref:`unitofwork_transaction`
|
| scalar(self, statement: 'Executable', params: 'Optional[_CoreSingleExecuteParams]' = None, *, execution_options: 'OrmExecuteOptionsParameter' = immutabledict({}), bind_arguments: 'Optional[_BindArguments]' = None, **kw: 'Any') -> 'Any'
| Execute a statement and return a scalar result.
|
| Usage and parameters are the same as that of
| :meth:`_orm.Session.execute`; the return result is a scalar Python
| value.
|
| scalars(self, statement: 'Executable', params: 'Optional[_CoreAnyExecuteParams]' = None, *, execution_options: 'OrmExecuteOptionsParameter' = immutabledict({}), bind_arguments: 'Optional[_BindArguments]' = None, **kw: 'Any') -> 'ScalarResult[Any]'
| Execute a statement and return the results as scalars.
|
| Usage and parameters are the same as that of
| :meth:`_orm.Session.execute`; the return result is a
| :class:`_result.ScalarResult` filtering object which
| will return single elements rather than :class:`_row.Row` objects.
|
| :return: a :class:`_result.ScalarResult` object
|
| .. versionadded:: 1.4.24 Added :meth:`_orm.Session.scalars`
|
| .. versionadded:: 1.4.26 Added :meth:`_orm.scoped_session.scalars`
|
| .. seealso::
|
| :ref:`orm_queryguide_select_orm_entities` - contrasts the behavior
| of :meth:`_orm.Session.execute` to :meth:`_orm.Session.scalars`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.orm.session.Session:
|
| deleted
| The set of all instances marked as 'deleted' within this ``Session``
|
| dirty
| The set of all persistent instances considered dirty.
|
| E.g.::
|
| some_mapped_object in session.dirty
|
| Instances are considered dirty when they were modified but not
| deleted.
|
| Note that this 'dirty' calculation is 'optimistic'; most
| attribute-setting or collection modification operations will
| mark an instance as 'dirty' and place it in this set, even if
| there is no net change to the attribute's value. At flush
| time, the value of each attribute is compared to its
| previously saved value, and if there's no net change, no SQL
| operation will occur (this is a more expensive operation so
| it's only done at flush time).
|
| To check if an instance has actionable net changes to its
| attributes, use the :meth:`.Session.is_modified` method.
|
| is_active
| True if this :class:`.Session` not in "partial rollback" state.
|
| .. versionchanged:: 1.4 The :class:`_orm.Session` no longer begins
| a new transaction immediately, so this attribute will be False
| when the :class:`_orm.Session` is first instantiated.
|
| "partial rollback" state typically indicates that the flush process
| of the :class:`_orm.Session` has failed, and that the
| :meth:`_orm.Session.rollback` method must be emitted in order to
| fully roll back the transaction.
|
| If this :class:`_orm.Session` is not in a transaction at all, the
| :class:`_orm.Session` will autobegin when it is first used, so in this
| case :attr:`_orm.Session.is_active` will return True.
|
| Otherwise, if this :class:`_orm.Session` is within a transaction,
| and that transaction has not been rolled back internally, the
| :attr:`_orm.Session.is_active` will also return True.
|
| .. seealso::
|
| :ref:`faq_session_rollback`
|
| :meth:`_orm.Session.in_transaction`
|
| new
| The set of all instances marked as 'new' within this ``Session``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.orm.session.Session:
|
| connection_callable = None
|
| dispatch = <sqlalchemy.event.base.SessionEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.orm.session._SessionClassMethods:
|
| close_all() -> 'None'
| Close *all* sessions in memory.
|
| .. deprecated:: 1.3 The :meth:`.Session.close_all` method is deprecated and will be removed in a future release. Please refer to :func:`.session.close_all_sessions`.
|
| identity_key(class_: 'Optional[Type[Any]]' = None, ident: 'Union[Any, Tuple[Any, ...]]' = None, *, instance: 'Optional[Any]' = None, row: 'Optional[Union[Row[Any], RowMapping]]' = None, identity_token: 'Optional[Any]' = None) -> '_IdentityKeyType[Any]'
| Return an identity key.
|
| This is an alias of :func:`.util.identity_key`.
|
| object_session(instance: 'object') -> 'Optional[Session]'
| Return the :class:`.Session` to which an object belongs.
|
| This is an alias of :func:`.object_session`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.orm.session._SessionClassMethods:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
sqlmodel.SmallInteger
Python Library Documentation: class SmallInteger in module sqlalchemy.sql.sqltypes
class SmallInteger(Integer)
| A type for smaller ``int`` integers.
|
| Typically generates a ``SMALLINT`` in DDL, and otherwise acts like
| a normal :class:`.Integer` on the Python side.
|
| Method resolution order:
| SmallInteger
| Integer
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'small_integer'
|
| ----------------------------------------------------------------------
| Methods inherited from Integer:
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Integer:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from HasExpressionLookup:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.StaticPool
Python Library Documentation: class StaticPool in module sqlalchemy.pool.impl
class StaticPool(sqlalchemy.pool.base.Pool)
| StaticPool(creator: 'Union[_CreatorFnType, _CreatorWRecFnType]', recycle: 'int' = -1, echo: 'log._EchoFlagType' = None, logging_name: 'Optional[str]' = None, reset_on_return: '_ResetStyleArgType' = True, events: 'Optional[List[Tuple[_ListenerFnType, str]]]' = None, dialect: 'Optional[Union[_ConnDialect, Dialect]]' = None, pre_ping: 'bool' = False, _dispatch: 'Optional[_DispatchCommon[Pool]]' = None)
|
| A Pool of exactly one connection, used for all requests.
|
| Reconnect-related functions such as ``recycle`` and connection
| invalidation (which is also used to support auto-reconnect) are only
| partially supported right now and may not yield good results.
|
| The :class:`.StaticPool` class **is compatible** with asyncio and
| :func:`_asyncio.create_async_engine`.
|
| Method resolution order:
| StaticPool
| sqlalchemy.pool.base.Pool
| sqlalchemy.log.Identified
| sqlalchemy.event.registry.EventTarget
| builtins.object
|
| Methods defined here:
|
| connection(...)
|
| dispose(self) -> 'None'
| Dispose of this pool.
|
| This method leaves the possibility of checked-out connections
| remaining open, as it only affects connections that are
| idle in the pool.
|
| .. seealso::
|
| :meth:`Pool.recreate`
|
| recreate(self) -> 'StaticPool'
| Return a new :class:`_pool.Pool`, of the same class as this one
| and configured with identical creation arguments.
|
| This method is used in conjunction with :meth:`dispose`
| to close out an entire :class:`_pool.Pool` and create a new one in
| its place.
|
| status(self) -> 'str'
| Returns a brief description of the state of this pool.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.pool.base.Pool:
|
| __init__(self, creator: 'Union[_CreatorFnType, _CreatorWRecFnType]', recycle: 'int' = -1, echo: 'log._EchoFlagType' = None, logging_name: 'Optional[str]' = None, reset_on_return: '_ResetStyleArgType' = True, events: 'Optional[List[Tuple[_ListenerFnType, str]]]' = None, dialect: 'Optional[Union[_ConnDialect, Dialect]]' = None, pre_ping: 'bool' = False, _dispatch: 'Optional[_DispatchCommon[Pool]]' = None)
| Construct a Pool.
|
| :param creator: a callable function that returns a DB-API
| connection object. The function will be called with
| parameters.
|
| :param recycle: If set to a value other than -1, number of
| seconds between connection recycling, which means upon
| checkout, if this timeout is surpassed the connection will be
| closed and replaced with a newly opened connection. Defaults to -1.
|
| :param logging_name: String identifier which will be used within
| the "name" field of logging records generated within the
| "sqlalchemy.pool" logger. Defaults to a hexstring of the object's
| id.
|
| :param echo: if True, the connection pool will log
| informational output such as when connections are invalidated
| as well as when connections are recycled to the default log handler,
| which defaults to ``sys.stdout`` for output.. If set to the string
| ``"debug"``, the logging will include pool checkouts and checkins.
|
| The :paramref:`_pool.Pool.echo` parameter can also be set from the
| :func:`_sa.create_engine` call by using the
| :paramref:`_sa.create_engine.echo_pool` parameter.
|
| .. seealso::
|
| :ref:`dbengine_logging` - further detail on how to configure
| logging.
|
| :param reset_on_return: Determine steps to take on
| connections as they are returned to the pool, which were
| not otherwise handled by a :class:`_engine.Connection`.
| Available from :func:`_sa.create_engine` via the
| :paramref:`_sa.create_engine.pool_reset_on_return` parameter.
|
| :paramref:`_pool.Pool.reset_on_return` can have any of these values:
|
| * ``"rollback"`` - call rollback() on the connection,
| to release locks and transaction resources.
| This is the default value. The vast majority
| of use cases should leave this value set.
| * ``"commit"`` - call commit() on the connection,
| to release locks and transaction resources.
| A commit here may be desirable for databases that
| cache query plans if a commit is emitted,
| such as Microsoft SQL Server. However, this
| value is more dangerous than 'rollback' because
| any data changes present on the transaction
| are committed unconditionally.
| * ``None`` - don't do anything on the connection.
| This setting may be appropriate if the database / DBAPI
| works in pure "autocommit" mode at all times, or if
| a custom reset handler is established using the
| :meth:`.PoolEvents.reset` event handler.
|
| * ``True`` - same as 'rollback', this is here for
| backwards compatibility.
| * ``False`` - same as None, this is here for
| backwards compatibility.
|
| For further customization of reset on return, the
| :meth:`.PoolEvents.reset` event hook may be used which can perform
| any connection activity desired on reset.
|
| .. seealso::
|
| :ref:`pool_reset_on_return`
|
| :meth:`.PoolEvents.reset`
|
| :param events: a list of 2-tuples, each of the form
| ``(callable, target)`` which will be passed to :func:`.event.listen`
| upon construction. Provided here so that event listeners
| can be assigned via :func:`_sa.create_engine` before dialect-level
| listeners are applied.
|
| :param dialect: a :class:`.Dialect` that will handle the job
| of calling rollback(), close(), or commit() on DBAPI connections.
| If omitted, a built-in "stub" dialect is used. Applications that
| make use of :func:`_sa.create_engine` should not use this parameter
| as it is handled by the engine creation strategy.
|
| :param pre_ping: if True, the pool will emit a "ping" (typically
| "SELECT 1", but is dialect-specific) on the connection
| upon checkout, to test if the connection is alive or not. If not,
| the connection is transparently re-connected and upon success, all
| other pooled connections established prior to that timestamp are
| invalidated. Requires that a dialect is passed as well to
| interpret the disconnection error.
|
| .. versionadded:: 1.2
|
| connect(self) -> 'PoolProxiedConnection'
| Return a DBAPI connection from the pool.
|
| The connection is instrumented such that when its
| ``close()`` method is called, the connection will be returned to
| the pool.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.pool.base.Pool:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.pool.base.Pool:
|
| dispatch = <sqlalchemy.event.base.PoolEventsDispatch object>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.log.Identified:
|
| logging_name = None
sqlmodel.String
Python Library Documentation: class String in module sqlalchemy.sql.sqltypes
class String(Concatenable, sqlalchemy.sql.type_api.TypeEngine)
| String(length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
|
| The base for all string and character types.
|
| In SQL, corresponds to VARCHAR.
|
| The `length` field is usually required when the `String` type is
| used within a CREATE TABLE statement, as VARCHAR requires a length
| on most databases.
|
| Method resolution order:
| String
| Concatenable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
| Create a string-holding type.
|
| :param length: optional, a length for the column for use in
| DDL and CAST expressions. May be safely omitted if no ``CREATE
| TABLE`` will be issued. Certain databases may require a
| ``length`` for use in DDL, and will raise an exception when
| the ``CREATE TABLE`` DDL is issued if a ``VARCHAR``
| with no length is included. Whether the value is
| interpreted as bytes or characters is database specific.
|
| :param collation: Optional, a column-level collation for
| use in DDL and CAST expressions. Renders using the
| COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
| E.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> from sqlalchemy import cast, select, String
| >>> print(select(cast("some string", String(collation="utf8"))))
| {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
|
| .. note::
|
| In most cases, the :class:`.Unicode` or :class:`.UnicodeText`
| datatypes should be used for a :class:`_schema.Column` that expects
| to store non-ascii data. These datatypes will ensure that the
| correct types are used on the database.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'string'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Concatenable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Concatenable:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comparator'>
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comp...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.TEXT
Python Library Documentation: class TEXT in module sqlalchemy.sql.sqltypes
class TEXT(Text)
| TEXT(length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
|
| The SQL TEXT type.
|
| Method resolution order:
| TEXT
| Text
| String
| Concatenable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'TEXT'
|
| ----------------------------------------------------------------------
| Methods inherited from String:
|
| __init__(self, length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
| Create a string-holding type.
|
| :param length: optional, a length for the column for use in
| DDL and CAST expressions. May be safely omitted if no ``CREATE
| TABLE`` will be issued. Certain databases may require a
| ``length`` for use in DDL, and will raise an exception when
| the ``CREATE TABLE`` DDL is issued if a ``VARCHAR``
| with no length is included. Whether the value is
| interpreted as bytes or characters is database specific.
|
| :param collation: Optional, a column-level collation for
| use in DDL and CAST expressions. Renders using the
| COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
| E.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> from sqlalchemy import cast, select, String
| >>> print(select(cast("some string", String(collation="utf8"))))
| {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
|
| .. note::
|
| In most cases, the :class:`.Unicode` or :class:`.UnicodeText`
| datatypes should be used for a :class:`_schema.Column` that expects
| to store non-ascii data. These datatypes will ensure that the
| correct types are used on the database.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from String:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Concatenable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Concatenable:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comparator'>
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comp...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.TIME
Python Library Documentation: class TIME in module sqlalchemy.sql.sqltypes
class TIME(Time)
| TIME(timezone: 'bool' = False)
|
| The SQL TIME type.
|
| Method resolution order:
| TIME
| Time
| _RenderISO8601NoT
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'TIME'
|
| ----------------------------------------------------------------------
| Methods inherited from Time:
|
| __init__(self, timezone: 'bool' = False)
| Initialize self. See help(type(self)) for accurate signature.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Time:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _RenderISO8601NoT:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.TIMESTAMP
Python Library Documentation: class TIMESTAMP in module sqlalchemy.sql.sqltypes
class TIMESTAMP(DateTime)
| TIMESTAMP(timezone: 'bool' = False)
|
| The SQL TIMESTAMP type.
|
| :class:`_types.TIMESTAMP` datatypes have support for timezone storage on
| some backends, such as PostgreSQL and Oracle Database. Use the
| :paramref:`~types.TIMESTAMP.timezone` argument in order to enable
| "TIMESTAMP WITH TIMEZONE" for these backends.
|
| Method resolution order:
| TIMESTAMP
| DateTime
| _RenderISO8601NoT
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, timezone: 'bool' = False)
| Construct a new :class:`_types.TIMESTAMP`.
|
| :param timezone: boolean. Indicates that the TIMESTAMP type should
| enable timezone support, if available on the target database.
| On a per-dialect basis is similar to "TIMESTAMP WITH TIMEZONE".
| If the target database does not support timezones, this flag is
| ignored.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'TIMESTAMP'
|
| ----------------------------------------------------------------------
| Methods inherited from DateTime:
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties inherited from DateTime:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _RenderISO8601NoT:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Table
Python Library Documentation: class Table in module sqlalchemy.sql.schema
class Table(sqlalchemy.sql.base.DialectKWArgs, HasSchemaAttr, sqlalchemy.sql.selectable.TableClause, sqlalchemy.inspection.Inspectable)
| Table(*args: 'Any', **kw: 'Any') -> 'Any'
|
| Represent a table in a database.
|
| e.g.::
|
| mytable = Table(
| "mytable",
| metadata,
| Column("mytable_id", Integer, primary_key=True),
| Column("value", String(50)),
| )
|
| The :class:`_schema.Table`
| object constructs a unique instance of itself based
| on its name and optional schema name within the given
| :class:`_schema.MetaData` object. Calling the :class:`_schema.Table`
| constructor with the same name and same :class:`_schema.MetaData` argument
| a second time will return the *same* :class:`_schema.Table`
| object - in this way
| the :class:`_schema.Table` constructor acts as a registry function.
|
| .. seealso::
|
| :ref:`metadata_describing` - Introduction to database metadata
|
| Method resolution order:
| Table
| sqlalchemy.sql.base.DialectKWArgs
| HasSchemaAttr
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.selectable.TableClause
| sqlalchemy.sql.roles.DMLTableRole
| sqlalchemy.sql.base.Immutable
| sqlalchemy.sql.selectable.NamedFromClause
| sqlalchemy.sql.selectable.FromClause
| sqlalchemy.sql.roles.AnonymizedFromClauseRole
| sqlalchemy.sql.roles.StrictFromClauseRole
| sqlalchemy.sql.roles.FromClauseRole
| sqlalchemy.sql.roles.ColumnsClauseRole
| sqlalchemy.sql.roles.JoinTargetRole
| sqlalchemy.sql.roles.AllowsLambdaRole
| sqlalchemy.sql.roles.UsesInspection
| sqlalchemy.sql.roles.ColumnListRole
| sqlalchemy.sql.roles.StructuralRole
| sqlalchemy.sql.selectable.Selectable
| sqlalchemy.sql.selectable.ReturnsRows
| sqlalchemy.sql.roles.ReturnsRowsRole
| sqlalchemy.sql.roles.SQLRole
| sqlalchemy.sql.elements.DQLDMLClauseElement
| sqlalchemy.sql.elements.ClauseElement
| sqlalchemy.sql.annotation.SupportsWrappingAnnotations
| sqlalchemy.sql.annotation.SupportsAnnotations
| sqlalchemy.sql.cache_key.MemoizedHasCacheKey
| sqlalchemy.sql.cache_key.HasCacheKey
| sqlalchemy.util.langhelpers.HasMemoized
| sqlalchemy.sql.traversals.HasCopyInternals
| sqlalchemy.sql.visitors.ExternallyTraversible
| sqlalchemy.sql.visitors.HasTraverseInternals
| sqlalchemy.sql.elements.CompilerElement
| sqlalchemy.sql.visitors.Visitable
| sqlalchemy.inspection.Inspectable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, name: 'str', metadata: 'MetaData', *args: 'SchemaItem', schema: 'Optional[Union[str, Literal[SchemaConst.BLANK_SCHEMA]]]' = None, quote: 'Optional[bool]' = None, quote_schema: 'Optional[bool]' = None, autoload_with: 'Optional[Union[Engine, Connection]]' = None, autoload_replace: 'bool' = True, keep_existing: 'bool' = False, extend_existing: 'bool' = False, resolve_fks: 'bool' = True, include_columns: 'Optional[Collection[str]]' = None, implicit_returning: 'bool' = True, comment: 'Optional[str]' = None, info: 'Optional[Dict[Any, Any]]' = None, listeners: 'Optional[_typing_Sequence[Tuple[str, Callable[..., Any]]]]' = None, prefixes: 'Optional[_typing_Sequence[str]]' = None, _extend_on: 'Optional[Set[Table]]' = None, _no_init: 'bool' = True, **kw: 'Any') -> 'None'
| Constructor for :class:`_schema.Table`.
|
|
| :param name: The name of this table as represented in the database.
|
| The table name, along with the value of the ``schema`` parameter,
| forms a key which uniquely identifies this :class:`_schema.Table`
| within
| the owning :class:`_schema.MetaData` collection.
| Additional calls to :class:`_schema.Table` with the same name,
| metadata,
| and schema name will return the same :class:`_schema.Table` object.
|
| Names which contain no upper case characters
| will be treated as case insensitive names, and will not be quoted
| unless they are a reserved word or contain special characters.
| A name with any number of upper case characters is considered
| to be case sensitive, and will be sent as quoted.
|
| To enable unconditional quoting for the table name, specify the flag
| ``quote=True`` to the constructor, or use the :class:`.quoted_name`
| construct to specify the name.
|
| :param metadata: a :class:`_schema.MetaData`
| object which will contain this
| table. The metadata is used as a point of association of this table
| with other tables which are referenced via foreign key. It also
| may be used to associate this table with a particular
| :class:`.Connection` or :class:`.Engine`.
|
| :param \*args: Additional positional arguments are used primarily
| to add the list of :class:`_schema.Column`
| objects contained within this
| table. Similar to the style of a CREATE TABLE statement, other
| :class:`.SchemaItem` constructs may be added here, including
| :class:`.PrimaryKeyConstraint`, and
| :class:`_schema.ForeignKeyConstraint`.
|
| :param autoload_replace: Defaults to ``True``; when using
| :paramref:`_schema.Table.autoload_with`
| in conjunction with :paramref:`_schema.Table.extend_existing`,
| indicates
| that :class:`_schema.Column` objects present in the already-existing
| :class:`_schema.Table`
| object should be replaced with columns of the same
| name retrieved from the autoload process. When ``False``, columns
| already present under existing names will be omitted from the
| reflection process.
|
| Note that this setting does not impact :class:`_schema.Column` objects
| specified programmatically within the call to :class:`_schema.Table`
| that
| also is autoloading; those :class:`_schema.Column` objects will always
| replace existing columns of the same name when
| :paramref:`_schema.Table.extend_existing` is ``True``.
|
| .. seealso::
|
| :paramref:`_schema.Table.autoload_with`
|
| :paramref:`_schema.Table.extend_existing`
|
| :param autoload_with: An :class:`_engine.Engine` or
| :class:`_engine.Connection` object,
| or a :class:`_reflection.Inspector` object as returned by
| :func:`_sa.inspect`
| against one, with which this :class:`_schema.Table`
| object will be reflected.
| When set to a non-None value, the autoload process will take place
| for this table against the given engine or connection.
|
| .. seealso::
|
| :ref:`metadata_reflection_toplevel`
|
| :meth:`_events.DDLEvents.column_reflect`
|
| :ref:`metadata_reflection_dbagnostic_types`
|
| :param extend_existing: When ``True``, indicates that if this
| :class:`_schema.Table` is already present in the given
| :class:`_schema.MetaData`,
| apply further arguments within the constructor to the existing
| :class:`_schema.Table`.
|
| If :paramref:`_schema.Table.extend_existing` or
| :paramref:`_schema.Table.keep_existing` are not set,
| and the given name
| of the new :class:`_schema.Table` refers to a :class:`_schema.Table`
| that is
| already present in the target :class:`_schema.MetaData` collection,
| and
| this :class:`_schema.Table`
| specifies additional columns or other constructs
| or flags that modify the table's state, an
| error is raised. The purpose of these two mutually-exclusive flags
| is to specify what action should be taken when a
| :class:`_schema.Table`
| is specified that matches an existing :class:`_schema.Table`,
| yet specifies
| additional constructs.
|
| :paramref:`_schema.Table.extend_existing`
| will also work in conjunction
| with :paramref:`_schema.Table.autoload_with` to run a new reflection
| operation against the database, even if a :class:`_schema.Table`
| of the same name is already present in the target
| :class:`_schema.MetaData`; newly reflected :class:`_schema.Column`
| objects
| and other options will be added into the state of the
| :class:`_schema.Table`, potentially overwriting existing columns
| and options of the same name.
|
| As is always the case with :paramref:`_schema.Table.autoload_with`,
| :class:`_schema.Column` objects can be specified in the same
| :class:`_schema.Table`
| constructor, which will take precedence. Below, the existing
| table ``mytable`` will be augmented with :class:`_schema.Column`
| objects
| both reflected from the database, as well as the given
| :class:`_schema.Column`
| named "y"::
|
| Table(
| "mytable",
| metadata,
| Column("y", Integer),
| extend_existing=True,
| autoload_with=engine,
| )
|
| .. seealso::
|
| :paramref:`_schema.Table.autoload_with`
|
| :paramref:`_schema.Table.autoload_replace`
|
| :paramref:`_schema.Table.keep_existing`
|
|
| :param implicit_returning: True by default - indicates that
| RETURNING can be used, typically by the ORM, in order to fetch
| server-generated values such as primary key values and
| server side defaults, on those backends which support RETURNING.
|
| In modern SQLAlchemy there is generally no reason to alter this
| setting, except for some backend specific cases
| (see :ref:`mssql_triggers` in the SQL Server dialect documentation
| for one such example).
|
| :param include_columns: A list of strings indicating a subset of
| columns to be loaded via the ``autoload`` operation; table columns who
| aren't present in this list will not be represented on the resulting
| ``Table`` object. Defaults to ``None`` which indicates all columns
| should be reflected.
|
| :param resolve_fks: Whether or not to reflect :class:`_schema.Table`
| objects
| related to this one via :class:`_schema.ForeignKey` objects, when
| :paramref:`_schema.Table.autoload_with` is
| specified. Defaults to True. Set to False to disable reflection of
| related tables as :class:`_schema.ForeignKey`
| objects are encountered; may be
| used either to save on SQL calls or to avoid issues with related tables
| that can't be accessed. Note that if a related table is already present
| in the :class:`_schema.MetaData` collection, or becomes present later,
| a
| :class:`_schema.ForeignKey` object associated with this
| :class:`_schema.Table` will
| resolve to that table normally.
|
| .. versionadded:: 1.3
|
| .. seealso::
|
| :paramref:`.MetaData.reflect.resolve_fks`
|
|
| :param info: Optional data dictionary which will be populated into the
| :attr:`.SchemaItem.info` attribute of this object.
|
| :param keep_existing: When ``True``, indicates that if this Table
| is already present in the given :class:`_schema.MetaData`, ignore
| further arguments within the constructor to the existing
| :class:`_schema.Table`, and return the :class:`_schema.Table`
| object as
| originally created. This is to allow a function that wishes
| to define a new :class:`_schema.Table` on first call, but on
| subsequent calls will return the same :class:`_schema.Table`,
| without any of the declarations (particularly constraints)
| being applied a second time.
|
| If :paramref:`_schema.Table.extend_existing` or
| :paramref:`_schema.Table.keep_existing` are not set,
| and the given name
| of the new :class:`_schema.Table` refers to a :class:`_schema.Table`
| that is
| already present in the target :class:`_schema.MetaData` collection,
| and
| this :class:`_schema.Table`
| specifies additional columns or other constructs
| or flags that modify the table's state, an
| error is raised. The purpose of these two mutually-exclusive flags
| is to specify what action should be taken when a
| :class:`_schema.Table`
| is specified that matches an existing :class:`_schema.Table`,
| yet specifies
| additional constructs.
|
| .. seealso::
|
| :paramref:`_schema.Table.extend_existing`
|
| :param listeners: A list of tuples of the form ``(<eventname>, <fn>)``
| which will be passed to :func:`.event.listen` upon construction.
| This alternate hook to :func:`.event.listen` allows the establishment
| of a listener function specific to this :class:`_schema.Table` before
| the "autoload" process begins. Historically this has been intended
| for use with the :meth:`.DDLEvents.column_reflect` event, however
| note that this event hook may now be associated with the
| :class:`_schema.MetaData` object directly::
|
| def listen_for_reflect(table, column_info):
| "handle the column reflection event"
| # ...
|
|
| t = Table(
| "sometable",
| autoload_with=engine,
| listeners=[("column_reflect", listen_for_reflect)],
| )
|
| .. seealso::
|
| :meth:`_events.DDLEvents.column_reflect`
|
| :param must_exist: When ``True``, indicates that this Table must already
| be present in the given :class:`_schema.MetaData` collection, else
| an exception is raised.
|
| :param prefixes:
| A list of strings to insert after CREATE in the CREATE TABLE
| statement. They will be separated by spaces.
|
| :param quote: Force quoting of this table's name on or off, corresponding
| to ``True`` or ``False``. When left at its default of ``None``,
| the column identifier will be quoted according to whether the name is
| case sensitive (identifiers with at least one upper case character are
| treated as case sensitive), or if it's a reserved word. This flag
| is only needed to force quoting of a reserved word which is not known
| by the SQLAlchemy dialect.
|
| .. note:: setting this flag to ``False`` will not provide
| case-insensitive behavior for table reflection; table reflection
| will always search for a mixed-case name in a case sensitive
| fashion. Case insensitive names are specified in SQLAlchemy only
| by stating the name with all lower case characters.
|
| :param quote_schema: same as 'quote' but applies to the schema identifier.
|
| :param schema: The schema name for this table, which is required if
| the table resides in a schema other than the default selected schema
| for the engine's database connection. Defaults to ``None``.
|
| If the owning :class:`_schema.MetaData` of this :class:`_schema.Table`
| specifies its
| own :paramref:`_schema.MetaData.schema` parameter,
| then that schema name will
| be applied to this :class:`_schema.Table`
| if the schema parameter here is set
| to ``None``. To set a blank schema name on a :class:`_schema.Table`
| that
| would otherwise use the schema set on the owning
| :class:`_schema.MetaData`,
| specify the special symbol :attr:`.BLANK_SCHEMA`.
|
| The quoting rules for the schema name are the same as those for the
| ``name`` parameter, in that quoting is applied for reserved words or
| case-sensitive names; to enable unconditional quoting for the schema
| name, specify the flag ``quote_schema=True`` to the constructor, or use
| the :class:`.quoted_name` construct to specify the name.
|
| :param comment: Optional string that will render an SQL comment on table
| creation.
|
| .. versionadded:: 1.2 Added the :paramref:`_schema.Table.comment`
| parameter
| to :class:`_schema.Table`.
|
| :param \**kw: Additional keyword arguments not mentioned above are
| dialect specific, and passed in the form ``<dialectname>_<argname>``.
| See the documentation regarding an individual dialect at
| :ref:`dialect_toplevel` for detail on documented arguments.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| add_is_dependent_on(self, table: 'Table') -> 'None'
| Add a 'dependency' for this Table.
|
| This is another Table object which must be created
| first before this one can, or dropped after this one.
|
| Usually, dependencies between tables are determined via
| ForeignKey objects. However, for other situations that
| create dependencies outside of foreign keys (rules, inheriting),
| this method can manually establish such a link.
|
| append_column(self, column: 'ColumnClause[Any]', replace_existing: 'bool' = False) -> 'None'
| Append a :class:`_schema.Column` to this :class:`_schema.Table`.
|
| The "key" of the newly added :class:`_schema.Column`, i.e. the
| value of its ``.key`` attribute, will then be available
| in the ``.c`` collection of this :class:`_schema.Table`, and the
| column definition will be included in any CREATE TABLE, SELECT,
| UPDATE, etc. statements generated from this :class:`_schema.Table`
| construct.
|
| Note that this does **not** change the definition of the table
| as it exists within any underlying database, assuming that
| table has already been created in the database. Relational
| databases support the addition of columns to existing tables
| using the SQL ALTER command, which would need to be
| emitted for an already-existing table that doesn't contain
| the newly added column.
|
| :param replace_existing: When ``True``, allows replacing existing
| columns. When ``False``, the default, an warning will be raised
| if a column with the same ``.key`` already exists. A future
| version of sqlalchemy will instead rise a warning.
|
| .. versionadded:: 1.4.0
|
| append_constraint(self, constraint: 'Union[Index, Constraint]') -> 'None'
| Append a :class:`_schema.Constraint` to this
| :class:`_schema.Table`.
|
| This has the effect of the constraint being included in any
| future CREATE TABLE statement, assuming specific DDL creation
| events have not been associated with the given
| :class:`_schema.Constraint` object.
|
| Note that this does **not** produce the constraint within the
| relational database automatically, for a table that already exists
| in the database. To add a constraint to an
| existing relational database table, the SQL ALTER command must
| be used. SQLAlchemy also provides the
| :class:`.AddConstraint` construct which can produce this SQL when
| invoked as an executable clause.
|
| create(self, bind: '_CreateDropBind', checkfirst: 'bool' = False) -> 'None'
| Issue a ``CREATE`` statement for this
| :class:`_schema.Table`, using the given
| :class:`.Connection` or :class:`.Engine`
| for connectivity.
|
| .. seealso::
|
| :meth:`_schema.MetaData.create_all`.
|
| drop(self, bind: '_CreateDropBind', checkfirst: 'bool' = False) -> 'None'
| Issue a ``DROP`` statement for this
| :class:`_schema.Table`, using the given
| :class:`.Connection` or :class:`.Engine` for connectivity.
|
| .. seealso::
|
| :meth:`_schema.MetaData.drop_all`.
|
| to_metadata(self, metadata: 'MetaData', schema: 'Union[str, Literal[SchemaConst.RETAIN_SCHEMA]]' = <SchemaConst.RETAIN_SCHEMA: 1>, referred_schema_fn: 'Optional[Callable[[Table, Optional[str], ForeignKeyConstraint, Optional[str]], Optional[str]]]' = None, name: 'Optional[str]' = None) -> 'Table'
| Return a copy of this :class:`_schema.Table` associated with a
| different :class:`_schema.MetaData`.
|
| E.g.::
|
| m1 = MetaData()
|
| user = Table("user", m1, Column("id", Integer, primary_key=True))
|
| m2 = MetaData()
| user_copy = user.to_metadata(m2)
|
| .. versionchanged:: 1.4 The :meth:`_schema.Table.to_metadata` function
| was renamed from :meth:`_schema.Table.tometadata`.
|
|
| :param metadata: Target :class:`_schema.MetaData` object,
| into which the
| new :class:`_schema.Table` object will be created.
|
| :param schema: optional string name indicating the target schema.
| Defaults to the special symbol :attr:`.RETAIN_SCHEMA` which indicates
| that no change to the schema name should be made in the new
| :class:`_schema.Table`. If set to a string name, the new
| :class:`_schema.Table`
| will have this new name as the ``.schema``. If set to ``None``, the
| schema will be set to that of the schema set on the target
| :class:`_schema.MetaData`, which is typically ``None`` as well,
| unless
| set explicitly::
|
| m2 = MetaData(schema="newschema")
|
| # user_copy_one will have "newschema" as the schema name
| user_copy_one = user.to_metadata(m2, schema=None)
|
| m3 = MetaData() # schema defaults to None
|
| # user_copy_two will have None as the schema name
| user_copy_two = user.to_metadata(m3, schema=None)
|
| :param referred_schema_fn: optional callable which can be supplied
| in order to provide for the schema name that should be assigned
| to the referenced table of a :class:`_schema.ForeignKeyConstraint`.
| The callable accepts this parent :class:`_schema.Table`, the
| target schema that we are changing to, the
| :class:`_schema.ForeignKeyConstraint` object, and the existing
| "target schema" of that constraint. The function should return the
| string schema name that should be applied. To reset the schema
| to "none", return the symbol :data:`.BLANK_SCHEMA`. To effect no
| change, return ``None`` or :data:`.RETAIN_SCHEMA`.
|
| .. versionchanged:: 1.4.33 The ``referred_schema_fn`` function
| may return the :data:`.BLANK_SCHEMA` or :data:`.RETAIN_SCHEMA`
| symbols.
|
| E.g.::
|
| def referred_schema_fn(table, to_schema, constraint, referred_schema):
| if referred_schema == "base_tables":
| return referred_schema
| else:
| return to_schema
|
|
| new_table = table.to_metadata(
| m2, schema="alt_schema", referred_schema_fn=referred_schema_fn
| )
|
| :param name: optional string name indicating the target table name.
| If not specified or None, the table name is retained. This allows
| a :class:`_schema.Table` to be copied to the same
| :class:`_schema.MetaData` target
| with a new name.
|
| tometadata(self, metadata: 'MetaData', schema: 'Union[str, Literal[SchemaConst.RETAIN_SCHEMA]]' = <SchemaConst.RETAIN_SCHEMA: 1>, referred_schema_fn: 'Optional[Callable[[Table, Optional[str], ForeignKeyConstraint, Optional[str]], Optional[str]]]' = None, name: 'Optional[str]' = None) -> 'Table'
| Return a copy of this :class:`_schema.Table`
| associated with a different
| :class:`_schema.MetaData`.
|
| .. deprecated:: 1.4 :meth:`_schema.Table.tometadata` is renamed to :meth:`_schema.Table.to_metadata`
|
| See :meth:`_schema.Table.to_metadata` for a full description.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, *args: 'Any', **kw: 'Any') -> 'Any'
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| autoincrement_column
| Returns the :class:`.Column` object which currently represents
| the "auto increment" column, if any, else returns None.
|
| This is based on the rules for :class:`.Column` as defined by the
| :paramref:`.Column.autoincrement` parameter, which generally means the
| column within a single integer column primary key constraint that is
| not constrained by a foreign key. If the table does not have such
| a primary key constraint, then there's no "autoincrement" column.
| A :class:`.Table` may have only one column defined as the
| "autoincrement" column.
|
| .. versionadded:: 2.0.4
|
| .. seealso::
|
| :paramref:`.Column.autoincrement`
|
| foreign_key_constraints
| :class:`_schema.ForeignKeyConstraint` objects referred to by this
| :class:`_schema.Table`.
|
| This list is produced from the collection of
| :class:`_schema.ForeignKey`
| objects currently associated.
|
|
| .. seealso::
|
| :attr:`_schema.Table.constraints`
|
| :attr:`_schema.Table.foreign_keys`
|
| :attr:`_schema.Table.indexes`
|
| key
| Return the 'key' for this :class:`_schema.Table`.
|
| This value is used as the dictionary key within the
| :attr:`_schema.MetaData.tables` collection. It is typically the same
| as that of :attr:`_schema.Table.name` for a table with no
| :attr:`_schema.Table.schema`
| set; otherwise it is typically of the form
| ``schemaname.tablename``.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'_columns': 'DedupeColumnCollection[Column[Any]]', ...
|
| __orig_bases__ = (<class 'sqlalchemy.sql.base.DialectKWArgs'>, <class ...
|
| __parameters__ = ()
|
| __visit_name__ = 'table'
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_options(...)
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| This is a two-level nested registry, keyed to ``<dialect_name>``
| and ``<argument_name>``. For example, the ``postgresql_where``
| argument would be locatable as::
|
| arg = my_object.dialect_options["postgresql"]["where"]
|
| .. versionadded:: 0.9.2
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form
|
| get_dialect_option(self, dialect: 'Dialect', argument_name: 'str', *, else_: 'Any' = None, deprecated_fallback: 'Optional[str]' = None) -> 'Any'
| Return the value of a dialect-specific option, or *else_* if
| this dialect does not register the given argument.
|
| This is useful for DDL compilers that may be inherited by
| third-party dialects whose ``construct_arguments`` do not
| include the same set of keys as the parent dialect.
|
| :param dialect: The dialect for which to retrieve the option.
| :param argument_name: The name of the argument to retrieve.
| :param else\_: The value to return if the argument is not present.
| :param deprecated_fallback: Optional dialect name to fall back to
| if the argument is not present for the current dialect. If the
| argument is present for the fallback dialect but not the current
| dialect, a deprecation warning will be emitted.
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| argument_for(dialect_name: 'str', argument_name: 'str', default: 'Any') -> 'None'
| Add a new kind of dialect-specific keyword argument for this class.
|
| E.g.::
|
| Index.argument_for("mydialect", "length", None)
|
| some_index = Index("a", "b", mydialect_length=5)
|
| The :meth:`.DialectKWArgs.argument_for` method is a per-argument
| way adding extra arguments to the
| :attr:`.DefaultDialect.construct_arguments` dictionary. This
| dictionary provides a list of argument names accepted by various
| schema-level constructs on behalf of a dialect.
|
| New dialects should typically specify this dictionary all at once as a
| data member of the dialect class. The use case for ad-hoc addition of
| argument names is typically for end-user code that is also using
| a custom compilation scheme which consumes the additional arguments.
|
| :param dialect_name: name of a dialect. The dialect must be
| locatable, else a :class:`.NoSuchModuleError` is raised. The
| dialect must also include an existing
| :attr:`.DefaultDialect.construct_arguments` collection, indicating
| that it participates in the keyword-argument validation and default
| system, else :class:`.ArgumentError` is raised. If the dialect does
| not include this collection, then any keyword argument can be
| specified on behalf of this dialect already. All dialects packaged
| within SQLAlchemy include this collection, however for third party
| dialects, support may vary.
|
| :param argument_name: name of the parameter.
|
| :param default: default value of the parameter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_kwargs
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| The arguments are present here in their original ``<dialect>_<kwarg>``
| format. Only arguments that were actually passed are included;
| unlike the :attr:`.DialectKWArgs.dialect_options` collection, which
| contains all options known by this dialect including defaults.
|
| The collection is also writable; keys are accepted of the
| form ``<dialect>_<kwarg>`` where the value will be assembled
| into the list of options.
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_options` - nested dictionary form
|
| kwargs
| A synonym for :attr:`.DialectKWArgs.dialect_kwargs`.
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.selectable.TableClause:
|
| delete(self) -> 'Delete'
| Generate a :func:`_expression.delete` construct against this
| :class:`_expression.TableClause`.
|
| E.g.::
|
| table.delete().where(table.c.id == 7)
|
| See :func:`_expression.delete` for argument and usage information.
|
| description(...)
|
| insert(self) -> 'util.preloaded.sql_dml.Insert'
| Generate an :class:`_sql.Insert` construct against this
| :class:`_expression.TableClause`.
|
| E.g.::
|
| table.insert().values(name="foo")
|
| See :func:`_expression.insert` for argument and usage information.
|
| update(self) -> 'Update'
| Generate an :func:`_expression.update` construct against this
| :class:`_expression.TableClause`.
|
| E.g.::
|
| table.update().where(table.c.id == 7).values(name="foo")
|
| See :func:`_expression.update` for argument and usage information.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.selectable.TableClause:
|
| implicit_returning = False
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.Immutable:
|
| params(self, *optionaldict: 'Any', **kwargs: 'Any') -> 'NoReturn'
|
| unique_params(self, *optionaldict: 'Any', **kwargs: 'Any') -> 'NoReturn'
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.selectable.NamedFromClause:
|
| table_valued(self) -> 'TableValuedColumn[Any]'
| Return a :class:`_sql.TableValuedColumn` object for this
| :class:`_expression.FromClause`.
|
| A :class:`_sql.TableValuedColumn` is a :class:`_sql.ColumnElement` that
| represents a complete row in a table. Support for this construct is
| backend dependent, and is supported in various forms by backends
| such as PostgreSQL, Oracle Database and SQL Server.
|
| E.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> from sqlalchemy import select, column, func, table
| >>> a = table("a", column("id"), column("x"), column("y"))
| >>> stmt = select(func.row_to_json(a.table_valued()))
| >>> print(stmt)
| {printsql}SELECT row_to_json(a) AS row_to_json_1
| FROM a
|
| .. versionadded:: 1.4.0b2
|
| .. seealso::
|
| :ref:`tutorial_functions` - in the :ref:`unified_tutorial`
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.selectable.NamedFromClause:
|
| named_with_column = True
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.selectable.FromClause:
|
| alias(self, name: 'Optional[str]' = None, flat: 'bool' = False) -> 'NamedFromClause'
| Return an alias of this :class:`_expression.FromClause`.
|
| E.g.::
|
| a2 = some_table.alias("a2")
|
| The above code creates an :class:`_expression.Alias`
| object which can be used
| as a FROM clause in any SELECT statement.
|
| .. seealso::
|
| :ref:`tutorial_using_aliases`
|
| :func:`_expression.alias`
|
| c(...)
| A synonym for :attr:`.FromClause.columns`
|
| :return: a :class:`.ColumnCollection`
|
| columns(...)
| A named-based collection of :class:`_expression.ColumnElement`
| objects maintained by this :class:`_expression.FromClause`.
|
| The :attr:`.columns`, or :attr:`.c` collection, is the gateway
| to the construction of SQL expressions using table-bound or
| other selectable-bound columns::
|
| select(mytable).where(mytable.c.somecolumn == 5)
|
| :return: a :class:`.ColumnCollection` object.
|
| entity_namespace(...)
| Return a namespace used for name-based access in SQL expressions.
|
| This is the namespace that is used to resolve "filter_by()" type
| expressions, such as::
|
| stmt.filter_by(address="some address")
|
| It defaults to the ``.c`` collection, however internally it can
| be overridden using the "entity_namespace" annotation to deliver
| alternative results.
|
| exported_columns(...)
| A :class:`_expression.ColumnCollection`
| that represents the "exported"
| columns of this :class:`_expression.Selectable`.
|
| The "exported" columns for a :class:`_expression.FromClause`
| object are synonymous
| with the :attr:`_expression.FromClause.columns` collection.
|
| .. versionadded:: 1.4
|
| .. seealso::
|
| :attr:`_expression.Selectable.exported_columns`
|
| :attr:`_expression.SelectBase.exported_columns`
|
| foreign_keys(...)
| Return the collection of :class:`_schema.ForeignKey` marker objects
| which this FromClause references.
|
| Each :class:`_schema.ForeignKey` is a member of a
| :class:`_schema.Table`-wide
| :class:`_schema.ForeignKeyConstraint`.
|
| .. seealso::
|
| :attr:`_schema.Table.foreign_key_constraints`
|
| is_derived_from(self, fromclause: 'Optional[FromClause]') -> 'bool'
| Return ``True`` if this :class:`_expression.FromClause` is
| 'derived' from the given ``FromClause``.
|
| An example would be an Alias of a Table is derived from that Table.
|
| join(self, right: '_FromClauseArgument', onclause: 'Optional[_ColumnExpressionArgument[bool]]' = None, isouter: 'bool' = False, full: 'bool' = False) -> 'Join'
| Return a :class:`_expression.Join` from this
| :class:`_expression.FromClause`
| to another :class:`FromClause`.
|
| E.g.::
|
| from sqlalchemy import join
|
| j = user_table.join(
| address_table, user_table.c.id == address_table.c.user_id
| )
| stmt = select(user_table).select_from(j)
|
| would emit SQL along the lines of:
|
| .. sourcecode:: sql
|
| SELECT user.id, user.name FROM user
| JOIN address ON user.id = address.user_id
|
| :param right: the right side of the join; this is any
| :class:`_expression.FromClause` object such as a
| :class:`_schema.Table` object, and
| may also be a selectable-compatible object such as an ORM-mapped
| class.
|
| :param onclause: a SQL expression representing the ON clause of the
| join. If left at ``None``, :meth:`_expression.FromClause.join`
| will attempt to
| join the two tables based on a foreign key relationship.
|
| :param isouter: if True, render a LEFT OUTER JOIN, instead of JOIN.
|
| :param full: if True, render a FULL OUTER JOIN, instead of LEFT OUTER
| JOIN. Implies :paramref:`.FromClause.join.isouter`.
|
| .. seealso::
|
| :func:`_expression.join` - standalone function
|
| :class:`_expression.Join` - the type of object produced
|
| outerjoin(self, right: '_FromClauseArgument', onclause: 'Optional[_ColumnExpressionArgument[bool]]' = None, full: 'bool' = False) -> 'Join'
| Return a :class:`_expression.Join` from this
| :class:`_expression.FromClause`
| to another :class:`FromClause`, with the "isouter" flag set to
| True.
|
| E.g.::
|
| from sqlalchemy import outerjoin
|
| j = user_table.outerjoin(
| address_table, user_table.c.id == address_table.c.user_id
| )
|
| The above is equivalent to::
|
| j = user_table.join(
| address_table, user_table.c.id == address_table.c.user_id, isouter=True
| )
|
| :param right: the right side of the join; this is any
| :class:`_expression.FromClause` object such as a
| :class:`_schema.Table` object, and
| may also be a selectable-compatible object such as an ORM-mapped
| class.
|
| :param onclause: a SQL expression representing the ON clause of the
| join. If left at ``None``, :meth:`_expression.FromClause.join`
| will attempt to
| join the two tables based on a foreign key relationship.
|
| :param full: if True, render a FULL OUTER JOIN, instead of
| LEFT OUTER JOIN.
|
| .. seealso::
|
| :meth:`_expression.FromClause.join`
|
| :class:`_expression.Join`
|
| primary_key(...)
| Return the iterable collection of :class:`_schema.Column` objects
| which comprise the primary key of this :class:`_selectable.FromClause`.
|
| For a :class:`_schema.Table` object, this collection is represented
| by the :class:`_schema.PrimaryKeyConstraint` which itself is an
| iterable collection of :class:`_schema.Column` objects.
|
| select(self) -> 'Select[Any]'
| Return a SELECT of this :class:`_expression.FromClause`.
|
|
| e.g.::
|
| stmt = some_table.select().where(some_table.c.id == 5)
|
| .. seealso::
|
| :func:`_expression.select` - general purpose
| method which allows for arbitrary column lists.
|
| tablesample(self, sampling: 'Union[float, Function[Any]]', name: 'Optional[str]' = None, seed: 'Optional[roles.ExpressionElementRole[Any]]' = None) -> 'TableSample'
| Return a TABLESAMPLE alias of this :class:`_expression.FromClause`.
|
| The return value is the :class:`_expression.TableSample`
| construct also
| provided by the top-level :func:`_expression.tablesample` function.
|
| .. seealso::
|
| :func:`_expression.tablesample` - usage guidelines and parameters
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.selectable.FromClause:
|
| is_selectable = True
|
| schema = None
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.roles.AllowsLambdaRole:
|
| allows_lambda = True
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.roles.UsesInspection:
|
| uses_inspection = True
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.selectable.Selectable:
|
| corresponding_column(self, column: 'KeyedColumnElement[Any]', require_embedded: 'bool' = False) -> 'Optional[KeyedColumnElement[Any]]'
| Given a :class:`_expression.ColumnElement`, return the exported
| :class:`_expression.ColumnElement` object from the
| :attr:`_expression.Selectable.exported_columns`
| collection of this :class:`_expression.Selectable`
| which corresponds to that
| original :class:`_expression.ColumnElement` via a common ancestor
| column.
|
| :param column: the target :class:`_expression.ColumnElement`
| to be matched.
|
| :param require_embedded: only return corresponding columns for
| the given :class:`_expression.ColumnElement`, if the given
| :class:`_expression.ColumnElement`
| is actually present within a sub-element
| of this :class:`_expression.Selectable`.
| Normally the column will match if
| it merely shares a common ancestor with one of the exported
| columns of this :class:`_expression.Selectable`.
|
| .. seealso::
|
| :attr:`_expression.Selectable.exported_columns` - the
| :class:`_expression.ColumnCollection`
| that is used for the operation.
|
| :meth:`_expression.ColumnCollection.corresponding_column`
| - implementation
| method.
|
| lateral(self, name: 'Optional[str]' = None) -> 'LateralFromClause'
| Return a LATERAL alias of this :class:`_expression.Selectable`.
|
| The return value is the :class:`_expression.Lateral` construct also
| provided by the top-level :func:`_expression.lateral` function.
|
| .. seealso::
|
| :ref:`tutorial_lateral_correlation` - overview of usage.
|
| replace_selectable(self, old: 'FromClause', alias: 'Alias') -> 'Self'
| Replace all occurrences of :class:`_expression.FromClause`
| 'old' with the given :class:`_expression.Alias`
| object, returning a copy of this :class:`_expression.FromClause`.
|
| .. deprecated:: 1.4 The :meth:`.Selectable.replace_selectable` method is deprecated, and will be removed in a future release. Similar functionality is available via the sqlalchemy.sql.visitors module.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.selectable.ReturnsRows:
|
| selectable
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.elements.ClauseElement:
|
| __bool__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __invert__(self)
|
| compare(self, other: 'ClauseElement', **kw: 'Any') -> 'bool'
| Compare this :class:`_expression.ClauseElement` to
| the given :class:`_expression.ClauseElement`.
|
| Subclasses should override the default behavior, which is a
| straight identity comparison.
|
| \**kw are arguments consumed by subclass ``compare()`` methods and
| may be used to modify the criteria for comparison
| (see :class:`_expression.ColumnElement`).
|
| self_group(self, against: 'Optional[OperatorType]' = None) -> 'ClauseElement'
| Apply a 'grouping' to this :class:`_expression.ClauseElement`.
|
| This method is overridden by subclasses to return a "grouping"
| construct, i.e. parenthesis. In particular it's used by "binary"
| expressions to provide a grouping around themselves when placed into a
| larger expression, as well as by :func:`_expression.select`
| constructs when placed into the FROM clause of another
| :func:`_expression.select`. (Note that subqueries should be
| normally created using the :meth:`_expression.Select.alias` method,
| as many
| platforms require nested SELECT statements to be named).
|
| As expressions are composed together, the application of
| :meth:`self_group` is automatic - end-user code should never
| need to use this method directly. Note that SQLAlchemy's
| clause constructs take operator precedence into account -
| so parenthesis might not be needed, for example, in
| an expression like ``x OR (y AND z)`` - AND takes precedence
| over OR.
|
| The base :meth:`self_group` method of
| :class:`_expression.ClauseElement`
| just returns self.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.elements.ClauseElement:
|
| is_clause_element = True
|
| is_dml = False
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.cache_key.HasCacheKey:
|
| inherit_cache = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.util.langhelpers.HasMemoized:
|
| memoized_instancemethod(fn: '_F') -> '_F'
| Decorate a method memoize its return value.
|
| :meta private:
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.util.langhelpers.HasMemoized:
|
| memoized_attribute = <class 'sqlalchemy.util.langhelpers.HasMemoized.m...
| A read-only @property that is only evaluated once.
|
| :meta private:
|
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.visitors.HasTraverseInternals:
|
| get_children(self, *, omit_attrs: 'Tuple[str, ...]' = (), **kw: 'Any') -> 'Iterable[HasTraverseInternals]'
| Return immediate child :class:`.visitors.HasTraverseInternals`
| elements of this :class:`.visitors.HasTraverseInternals`.
|
| This is used for visit traversal.
|
| \**kw may contain flags that change the collection that is
| returned, for example to return a subset of items in order to
| cut down on larger traversals, or to return child items from a
| different context (such as schema-level collections instead of
| clause-level).
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.elements.CompilerElement:
|
| compile(self, bind: 'Optional[_HasDialect]' = None, dialect: 'Optional[Dialect]' = None, **kw: 'Any') -> 'Compiled'
| Compile this SQL expression.
|
| The return value is a :class:`~.Compiled` object.
| Calling ``str()`` or ``unicode()`` on the returned value will yield a
| string representation of the result. The
| :class:`~.Compiled` object also can return a
| dictionary of bind parameter names and values
| using the ``params`` accessor.
|
| :param bind: An :class:`.Connection` or :class:`.Engine` which
| can provide a :class:`.Dialect` in order to generate a
| :class:`.Compiled` object. If the ``bind`` and
| ``dialect`` parameters are both omitted, a default SQL compiler
| is used.
|
| :param column_keys: Used for INSERT and UPDATE statements, a list of
| column names which should be present in the VALUES clause of the
| compiled statement. If ``None``, all columns from the target table
| object are rendered.
|
| :param dialect: A :class:`.Dialect` instance which can generate
| a :class:`.Compiled` object. This argument takes precedence over
| the ``bind`` argument.
|
| :param compile_kwargs: optional dictionary of additional parameters
| that will be passed through to the compiler within all "visit"
| methods. This allows any custom flag to be passed through to
| a custom compilation construct, for example. It is also used
| for the case of passing the ``literal_binds`` flag through::
|
| from sqlalchemy.sql import table, column, select
|
| t = table("t", column("x"))
|
| s = select(t).where(t.c.x == 5)
|
| print(s.compile(compile_kwargs={"literal_binds": True}))
|
| .. seealso::
|
| :ref:`faq_sql_expression_string`
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.elements.CompilerElement:
|
| stringify_dialect = 'default'
|
| supports_execution = False
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Text
Python Library Documentation: class Text in module sqlalchemy.sql.sqltypes
class Text(String)
| Text(length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
|
| A variably sized string type.
|
| In SQL, usually corresponds to CLOB or TEXT. In general, TEXT objects
| do not have a length; while some databases will accept a length
| argument here, it will be rejected by others.
|
| Method resolution order:
| Text
| String
| Concatenable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'text'
|
| ----------------------------------------------------------------------
| Methods inherited from String:
|
| __init__(self, length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
| Create a string-holding type.
|
| :param length: optional, a length for the column for use in
| DDL and CAST expressions. May be safely omitted if no ``CREATE
| TABLE`` will be issued. Certain databases may require a
| ``length`` for use in DDL, and will raise an exception when
| the ``CREATE TABLE`` DDL is issued if a ``VARCHAR``
| with no length is included. Whether the value is
| interpreted as bytes or characters is database specific.
|
| :param collation: Optional, a column-level collation for
| use in DDL and CAST expressions. Renders using the
| COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
| E.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> from sqlalchemy import cast, select, String
| >>> print(select(cast("some string", String(collation="utf8"))))
| {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
|
| .. note::
|
| In most cases, the :class:`.Unicode` or :class:`.UnicodeText`
| datatypes should be used for a :class:`_schema.Column` that expects
| to store non-ascii data. These datatypes will ensure that the
| correct types are used on the database.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from String:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Concatenable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Concatenable:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comparator'>
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comp...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Time
Python Library Documentation: class Time in module sqlalchemy.sql.sqltypes
class Time(_RenderISO8601NoT, HasExpressionLookup, sqlalchemy.sql.type_api.TypeEngine)
| Time(timezone: 'bool' = False)
|
| A type for ``datetime.time()`` objects.
|
| Method resolution order:
| Time
| _RenderISO8601NoT
| HasExpressionLookup
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, timezone: 'bool' = False)
| Initialize self. See help(type(self)) for accurate signature.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'time'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _RenderISO8601NoT:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from HasExpressionLookup:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.HasExpressionLookup.Compa...
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.HasExpressionLook...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.TupleType
Python Library Documentation: class TupleType in module sqlalchemy.sql.sqltypes
class TupleType(sqlalchemy.sql.type_api.TypeEngine)
| TupleType(*types: '_TypeEngineArgument[Any]')
|
| represent the composite type of a Tuple.
|
| Method resolution order:
| TupleType
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, *types: '_TypeEngineArgument[Any]')
| Initialize self. See help(type(self)) for accurate signature.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'types': 'List[TypeEngine[Any]]'}
|
| __parameters__ = ()
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| 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``.
|
| .. tip::
|
| 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.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| get_dbapi_type(self, dbapi: 'DBAPIModule') -> 'Optional[Any]'
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect: 'Dialect') -> 'Optional[_LiteralProcessorType[_T]]'
| 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.
|
| .. tip::
|
| 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`
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeEngine.Comparator'>
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| comparator_factory = <class 'sqlalchemy.sql.type_api.TypeEngine.Compar...
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| Function to initialize subclasses.
sqlmodel.TypeDecorator
Python Library Documentation: class TypeDecorator in module sqlalchemy.sql.type_api
class TypeDecorator(sqlalchemy.sql.base.SchemaEventTarget, ExternalType, TypeEngine)
| TypeDecorator(*args: 'Any', **kwargs: 'Any')
|
| Allows the creation of types which add additional functionality
| to an existing type.
|
| This method is preferred to direct subclassing of SQLAlchemy's
| built-in types as it ensures that all required functionality of
| the underlying type is kept in place.
|
| Typical usage::
|
| import sqlalchemy.types as types
|
|
| class MyType(types.TypeDecorator):
| """Prefixes Unicode values with "PREFIX:" on the way in and
| strips it off on the way out.
| """
|
| impl = types.Unicode
|
| cache_ok = True
|
| def process_bind_param(self, value, dialect):
| return "PREFIX:" + value
|
| def process_result_value(self, value, dialect):
| return value[7:]
|
| def copy(self, **kw):
| return MyType(self.impl.length)
|
| The class-level ``impl`` attribute is required, and can reference any
| :class:`.TypeEngine` class. Alternatively, the :meth:`load_dialect_impl`
| method can be used to provide different type classes based on the dialect
| given; in this case, the ``impl`` variable can reference
| ``TypeEngine`` as a placeholder.
|
| The :attr:`.TypeDecorator.cache_ok` class-level flag indicates if this
| custom :class:`.TypeDecorator` 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:`.TypeDecorator` 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:`.TypeDecorator.cache_ok` for further notes on how this works.
|
| Types that receive a Python type that isn't similar to the ultimate type
| used may want to define the :meth:`TypeDecorator.coerce_compared_value`
| method. This is used to give the expression system a hint when coercing
| Python objects into bind parameters within expressions. Consider this
| expression::
|
| mytable.c.somecol + datetime.date(2009, 5, 15)
|
| Above, if "somecol" is an ``Integer`` variant, it makes sense that
| we're doing date arithmetic, where above is usually interpreted
| by databases as adding a number of days to the given date.
| The expression system does the right thing by not attempting to
| coerce the "date()" value into an integer-oriented bind parameter.
|
| However, in the case of ``TypeDecorator``, we are usually changing an
| incoming Python type to something new - ``TypeDecorator`` by default will
| "coerce" the non-typed side to be the same type as itself. Such as below,
| we define an "epoch" type that stores a date value as an integer::
|
| class MyEpochType(types.TypeDecorator):
| impl = types.Integer
|
| cache_ok = True
|
| epoch = datetime.date(1970, 1, 1)
|
| def process_bind_param(self, value, dialect):
| return (value - self.epoch).days
|
| def process_result_value(self, value, dialect):
| return self.epoch + timedelta(days=value)
|
| Our expression of ``somecol + date`` with the above type will coerce the
| "date" on the right side to also be treated as ``MyEpochType``.
|
| This behavior can be overridden via the
| :meth:`~TypeDecorator.coerce_compared_value` method, which returns a type
| that should be used for the value of the expression. Below we set it such
| that an integer value will be treated as an ``Integer``, and any other
| value is assumed to be a date and will be treated as a ``MyEpochType``::
|
| def coerce_compared_value(self, op, value):
| if isinstance(value, int):
| return Integer()
| else:
| return self
|
| .. warning::
|
| Note that the **behavior of coerce_compared_value is not inherited
| by default from that of the base type**.
| If the :class:`.TypeDecorator` is augmenting a
| type that requires special logic for certain types of operators,
| this method **must** be overridden. A key example is when decorating
| the :class:`_postgresql.JSON` and :class:`_postgresql.JSONB` types;
| the default rules of :meth:`.TypeEngine.coerce_compared_value` should
| be used in order to deal with operators like index operations::
|
| from sqlalchemy import JSON
| from sqlalchemy import TypeDecorator
|
|
| class MyJsonType(TypeDecorator):
| impl = JSON
|
| cache_ok = True
|
| def coerce_compared_value(self, op, value):
| return self.impl.coerce_compared_value(op, value)
|
| Without the above step, index operations such as ``mycol['foo']``
| will cause the index value ``'foo'`` to be JSON encoded.
|
| Similarly, when working with the :class:`.ARRAY` datatype, the
| type coercion for index operations (e.g. ``mycol[5]``) is also
| handled by :meth:`.TypeDecorator.coerce_compared_value`, where
| again a simple override is sufficient unless special rules are needed
| for particular operators::
|
| from sqlalchemy import ARRAY
| from sqlalchemy import TypeDecorator
|
|
| class MyArrayType(TypeDecorator):
| impl = ARRAY
|
| cache_ok = True
|
| def coerce_compared_value(self, op, value):
| return self.impl.coerce_compared_value(op, value)
|
| Method resolution order:
| TypeDecorator
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| ExternalType
| TypeEngineMixin
| TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __getattr__(self, key: 'str') -> 'Any'
| Proxy all other undefined accessors to the underlying
| implementation.
|
| __init__(self, *args: 'Any', **kwargs: 'Any')
| Construct a :class:`.TypeDecorator`.
|
| Arguments sent here are passed to the constructor
| of the class assigned to the ``impl`` class level attribute,
| assuming the ``impl`` is a callable, and the resulting
| object is assigned to the ``self.impl`` instance attribute
| (thus overriding the class attribute of the same name).
|
| If the class level ``impl`` is not a callable (the unusual case),
| it will be assigned to the same instance attribute 'as-is',
| ignoring those arguments passed to the constructor.
|
| Subclasses can override this to customize the generation
| of ``self.impl`` entirely.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| bind_expression(self, bindparam: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression which will typically wrap the given parameter.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** necessarily
| called against specific values, and should not be confused with the
| :meth:`_types.TypeDecorator.process_bind_param` method, which is
| the more typical method that processes the actual value passed to a
| particular parameter at statement execution time.
|
| Subclasses of :class:`_types.TypeDecorator` can override this method
| to provide custom bind expression behavior for the type. This
| implementation will **replace** that of the underlying implementation
| type.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_T]]'
| Provide a bound value processing function for the
| given :class:`.Dialect`.
|
| This is the method that fulfills the :class:`.TypeEngine`
| contract for bound value conversion which normally occurs via
| the :meth:`_types.TypeEngine.bind_processor` method.
|
| .. note::
|
| User-defined subclasses of :class:`_types.TypeDecorator` should
| **not** implement this method, and should instead implement
| :meth:`_types.TypeDecorator.process_bind_param` so that the "inner"
| processing provided by the implementing type is maintained.
|
| :param dialect: Dialect instance in use.
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'Any'
| Suggest a type for a 'coerced' Python value in an expression.
|
| By default, returns self. This method is called by
| the expression system when an object using this type is
| on the left or right side of an expression against a plain Python
| object which does not yet have a SQLAlchemy type assigned::
|
| expr = table.c.somecolumn + 35
|
| Where above, if ``somecolumn`` uses this type, this method will
| be called with the value ``operator.add``
| and ``35``. The return value is whatever SQLAlchemy type should
| be used for ``35`` for this particular operation.
|
| column_expression(self, column: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a SELECT column expression, return a wrapping SQL expression.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values, and should not be confused with the
| :meth:`_types.TypeDecorator.process_result_value` method, which is
| the more typical method that processes the actual value returned
| in a result row subsequent to statement execution time.
|
| Subclasses of :class:`_types.TypeDecorator` can override this method
| to provide custom column expression behavior for the type. This
| implementation will **replace** that of the underlying implementation
| type.
|
| See the description of :meth:`_types.TypeEngine.column_expression`
| for a complete description of the method's use.
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Given two values, compare them for equality.
|
| By default this calls upon :meth:`.TypeEngine.compare_values`
| of the underlying "impl", which in turn usually
| uses the Python equals operator ``==``.
|
| This function is used by the ORM to compare
| an original-loaded value with an intercepted
| "changed" value, to determine if a net change
| has occurred.
|
| copy(self, **kw: 'Any') -> 'Self'
| Produce a copy of this :class:`.TypeDecorator` instance.
|
| This is a shallow copy and is provided to fulfill part of
| the :class:`.TypeEngine` contract. It usually does not
| need to be overridden unless the user-defined :class:`.TypeDecorator`
| has local state that should be deep-copied.
|
| get_dbapi_type(self, dbapi: 'DBAPIModule') -> 'Optional[Any]'
| Return the DBAPI type object represented by this
| :class:`.TypeDecorator`.
|
| By default this calls upon :meth:`.TypeEngine.get_dbapi_type` of the
| underlying "impl".
|
| impl_instance(...)
|
| literal_processor(self, dialect: 'Dialect') -> 'Optional[_LiteralProcessorType[_T]]'
| Provide a literal processing function for the given
| :class:`.Dialect`.
|
| This is the method that fulfills the :class:`.TypeEngine`
| contract for literal value conversion which normally occurs via
| the :meth:`_types.TypeEngine.literal_processor` method.
|
| .. note::
|
| User-defined subclasses of :class:`_types.TypeDecorator` should
| **not** implement this method, and should instead implement
| :meth:`_types.TypeDecorator.process_literal_param` so that the
| "inner" processing provided by the implementing type is maintained.
|
| load_dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[Any]'
| Return a :class:`.TypeEngine` object corresponding to a dialect.
|
| This is an end-user override hook that can be used to provide
| differing types depending on the given dialect. It is used
| by the :class:`.TypeDecorator` implementation of :meth:`type_engine`
| to help determine what type should ultimately be returned
| for a given :class:`.TypeDecorator`.
|
| By default returns ``self.impl``.
|
| process_bind_param(self, value: 'Optional[_T]', dialect: 'Dialect') -> 'Any'
| Receive a bound parameter value to be converted.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for incoming data values.
| This method is called at **statement execution time** and is passed
| the literal Python data value which is to be associated with a bound
| parameter in the statement.
|
| The operation could be anything desired to perform custom
| behavior, such as transforming or serializing data.
| This could also be used as a hook for validating logic.
|
| :param value: Data to operate upon, of any type expected by
| this method in the subclass. Can be ``None``.
| :param dialect: the :class:`.Dialect` in use.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| :meth:`_types.TypeDecorator.process_result_value`
|
| process_literal_param(self, value: 'Optional[_T]', dialect: 'Dialect') -> 'str'
| Receive a literal parameter value to be rendered inline within
| a statement.
|
| .. note::
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. Unlike other SQL
| compilation methods, it is passed a specific Python value to be
| rendered as a string. However it should not be confused with the
| :meth:`_types.TypeDecorator.process_bind_param` method, which is
| the more typical method that processes the actual value passed to a
| particular parameter at statement execution time.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for incoming data values
| that are in the special case of being rendered as literals.
|
| The returned string will be rendered into the output string.
|
| process_result_value(self, value: 'Optional[Any]', dialect: 'Dialect') -> 'Optional[_T]'
| Receive a result-row column value to be converted.
|
| Custom subclasses of :class:`_types.TypeDecorator` should override
| this method to provide custom behaviors for data values
| being received in result rows coming from the database.
| This method is called at **result fetching time** and is passed
| the literal Python data value that's extracted from a database result
| row.
|
| The operation could be anything desired to perform custom
| behavior, such as transforming or deserializing data.
|
| :param value: Data to operate upon, of any type expected by
| this method in the subclass. Can be ``None``.
| :param dialect: the :class:`.Dialect` in use.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| :meth:`_types.TypeDecorator.process_bind_param`
|
| result_processor(self, dialect: 'Dialect', coltype: 'Any') -> 'Optional[_ResultProcessorType[_T]]'
| Provide a result value processing function for the given
| :class:`.Dialect`.
|
| This is the method that fulfills the :class:`.TypeEngine`
| contract for bound value conversion which normally occurs via
| the :meth:`_types.TypeEngine.result_processor` method.
|
| .. note::
|
| User-defined subclasses of :class:`_types.TypeDecorator` should
| **not** implement this method, and should instead implement
| :meth:`_types.TypeDecorator.process_result_value` so that the
| "inner" processing provided by the implementing type is maintained.
|
| :param dialect: Dialect instance in use.
| :param coltype: A SQLAlchemy data type
|
| type_engine(self, dialect: 'Dialect') -> 'TypeEngine[Any]'
| Return a dialect-specific :class:`.TypeEngine` instance
| for this :class:`.TypeDecorator`.
|
| In most cases this returns a dialect-adapted form of
| the :class:`.TypeEngine` type represented by ``self.impl``.
| Makes usage of :meth:`dialect_impl`.
| Behavior can be customized here by overriding
| :meth:`load_dialect_impl`.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| comparator_factory
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
| sort_key_function
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeDecorator.Comparator'...
| A :class:`.TypeEngine.Comparator` that is specific to
| :class:`.TypeDecorator`.
|
| User-defined :class:`.TypeDecorator` classes should not typically
| need to modify this.
|
|
| __annotations__ = {'coerce_to_is_types': 'Sequence[Type[Any]]', 'impl'...
|
| __parameters__ = ()
|
| __visit_name__ = 'type_decorator'
|
| coerce_to_is_types = (<class 'NoneType'>,)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ExternalType:
|
| cache_ok = None
|
| ----------------------------------------------------------------------
| Methods inherited from TypeEngine:
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from 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.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.UUID
Python Library Documentation: class UUID in module sqlalchemy.sql.sqltypes
class UUID(Uuid, sqlalchemy.sql.type_api.NativeForEmulated)
| UUID(as_uuid: 'bool' = True)
|
| Represent the SQL UUID type.
|
| This is the SQL-native form of the :class:`_types.Uuid` database agnostic
| datatype, and is backwards compatible with the previous PostgreSQL-only
| version of ``UUID``.
|
| The :class:`_sqltypes.UUID` datatype only works on databases that have a
| SQL datatype named ``UUID``. It will not function for backends which don't
| have this exact-named type, including SQL Server. For backend-agnostic UUID
| values with native support, including for SQL Server's ``UNIQUEIDENTIFIER``
| datatype, use the :class:`_sqltypes.Uuid` datatype.
|
| .. versionadded:: 2.0
|
| .. seealso::
|
| :class:`_sqltypes.Uuid`
|
| Method resolution order:
| UUID
| Uuid
| sqlalchemy.sql.type_api.Emulated
| sqlalchemy.sql.type_api.NativeForEmulated
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, as_uuid: 'bool' = True)
| Construct a :class:`_sqltypes.UUID` type.
|
|
| :param as_uuid=True: if True, values will be interpreted
| as Python uuid objects, converting to/from string via the
| DBAPI.
|
| .. versionchanged: 2.0 ``as_uuid`` now defaults to ``True``.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| adapt_emulated_to_native(impl, **kw)
| Given an impl, adapt this type's class to the impl assuming
| "native".
|
| The impl will be an :class:`.Emulated` class but not a
| :class:`.NativeForEmulated`.
|
| e.g.: postgresql.ENUM produces a type given an Enum instance.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'UUID'
|
| ----------------------------------------------------------------------
| Methods inherited from Uuid:
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_UUID_RETURN]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op, value)
| See :meth:`.TypeEngine.coerce_compared_value` for a description.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Uuid:
|
| native
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Uuid:
|
| collation = None
|
| length = None
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.Emulated:
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
|
| adapt_to_emulated(self, impltype: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| Given an impl class, adapt this type to the impl assuming
| "emulated".
|
| The impl should also be an "emulated" version of this type,
| most likely the same class as this type itself.
|
| e.g.: sqltypes.Enum adapts to the Enum class.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.type_api.Emulated:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.type_api.NativeForEmulated:
|
| adapt_native_to_emulated(impl: 'Union[TypeEngine[Any], TypeEngineMixin]', **kw: 'Any') -> 'TypeEngine[Any]'
| Given an impl, adapt this type's class to the impl assuming
| "emulated".
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| get_dbapi_type(self, dbapi: 'DBAPIModule') -> 'Optional[Any]'
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeEngine.Comparator'>
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| comparator_factory = <class 'sqlalchemy.sql.type_api.TypeEngine.Compar...
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Unicode
Python Library Documentation: class Unicode in module sqlalchemy.sql.sqltypes
class Unicode(String)
| Unicode(length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
|
| A variable length Unicode string type.
|
| The :class:`.Unicode` type is a :class:`.String` subclass that assumes
| input and output strings that may contain non-ASCII characters, and for
| some backends implies an underlying column type that is explicitly
| supporting of non-ASCII data, such as ``NVARCHAR`` on Oracle Database and
| SQL Server. This will impact the output of ``CREATE TABLE`` statements and
| ``CAST`` functions at the dialect level.
|
| The character encoding used by the :class:`.Unicode` type that is used to
| transmit and receive data to the database is usually determined by the
| DBAPI itself. All modern DBAPIs accommodate non-ASCII strings but may have
| different methods of managing database encodings; if necessary, this
| encoding should be configured as detailed in the notes for the target DBAPI
| in the :ref:`dialect_toplevel` section.
|
| In modern SQLAlchemy, use of the :class:`.Unicode` datatype does not
| imply any encoding/decoding behavior within SQLAlchemy itself. In Python
| 3, all string objects are inherently Unicode capable, and SQLAlchemy
| does not produce bytestring objects nor does it accommodate a DBAPI that
| does not return Python Unicode objects in result sets for string values.
|
| .. warning:: Some database backends, particularly SQL Server with pyodbc,
| are known to have undesirable behaviors regarding data that is noted
| as being of ``NVARCHAR`` type as opposed to ``VARCHAR``, including
| datatype mismatch errors and non-use of indexes. See the section
| on :meth:`.DialectEvents.do_setinputsizes` for background on working
| around unicode character issues for backends like SQL Server with
| pyodbc as well as cx_Oracle.
|
| .. seealso::
|
| :class:`.UnicodeText` - unlengthed textual counterpart
| to :class:`.Unicode`.
|
| :meth:`.DialectEvents.do_setinputsizes`
|
| Method resolution order:
| Unicode
| String
| Concatenable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'unicode'
|
| ----------------------------------------------------------------------
| Methods inherited from String:
|
| __init__(self, length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
| Create a string-holding type.
|
| :param length: optional, a length for the column for use in
| DDL and CAST expressions. May be safely omitted if no ``CREATE
| TABLE`` will be issued. Certain databases may require a
| ``length`` for use in DDL, and will raise an exception when
| the ``CREATE TABLE`` DDL is issued if a ``VARCHAR``
| with no length is included. Whether the value is
| interpreted as bytes or characters is database specific.
|
| :param collation: Optional, a column-level collation for
| use in DDL and CAST expressions. Renders using the
| COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
| E.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> from sqlalchemy import cast, select, String
| >>> print(select(cast("some string", String(collation="utf8"))))
| {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
|
| .. note::
|
| In most cases, the :class:`.Unicode` or :class:`.UnicodeText`
| datatypes should be used for a :class:`_schema.Column` that expects
| to store non-ascii data. These datatypes will ensure that the
| correct types are used on the database.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from String:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Concatenable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Concatenable:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comparator'>
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comp...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.UnicodeText
Python Library Documentation: class UnicodeText in module sqlalchemy.sql.sqltypes
class UnicodeText(Text)
| UnicodeText(length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
|
| An unbounded-length Unicode string type.
|
| See :class:`.Unicode` for details on the unicode
| behavior of this object.
|
| Like :class:`.Unicode`, usage the :class:`.UnicodeText` type implies a
| unicode-capable type being used on the backend, such as
| ``NCLOB``, ``NTEXT``.
|
| Method resolution order:
| UnicodeText
| Text
| String
| Concatenable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'unicode_text'
|
| ----------------------------------------------------------------------
| Methods inherited from String:
|
| __init__(self, length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
| Create a string-holding type.
|
| :param length: optional, a length for the column for use in
| DDL and CAST expressions. May be safely omitted if no ``CREATE
| TABLE`` will be issued. Certain databases may require a
| ``length`` for use in DDL, and will raise an exception when
| the ``CREATE TABLE`` DDL is issued if a ``VARCHAR``
| with no length is included. Whether the value is
| interpreted as bytes or characters is database specific.
|
| :param collation: Optional, a column-level collation for
| use in DDL and CAST expressions. Renders using the
| COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
| E.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> from sqlalchemy import cast, select, String
| >>> print(select(cast("some string", String(collation="utf8"))))
| {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
|
| .. note::
|
| In most cases, the :class:`.Unicode` or :class:`.UnicodeText`
| datatypes should be used for a :class:`_schema.Column` that expects
| to store non-ascii data. These datatypes will ensure that the
| correct types are used on the database.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from String:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Concatenable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Concatenable:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comparator'>
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comp...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.UniqueConstraint
Python Library Documentation: class UniqueConstraint in module sqlalchemy.sql.schema
class UniqueConstraint(ColumnCollectionConstraint)
| UniqueConstraint(*columns: '_DDLColumnArgument', name: '_ConstraintNameArgument' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, info: 'Optional[_InfoType]' = None, _autoattach: 'bool' = True, _column_flag: 'bool' = False, _gather_expressions: 'Optional[List[_DDLColumnArgument]]' = None, **dialect_kw: 'Any') -> 'None'
|
| A table-level UNIQUE constraint.
|
| Defines a single column or composite UNIQUE constraint. For a no-frills,
| single column constraint, adding ``unique=True`` to the ``Column``
| definition is a shorthand equivalent for an unnamed, single column
| UniqueConstraint.
|
| Method resolution order:
| UniqueConstraint
| ColumnCollectionConstraint
| ColumnCollectionMixin
| Constraint
| sqlalchemy.sql.base.DialectKWArgs
| HasConditionalDDL
| SchemaItem
| sqlalchemy.sql.base.SchemaVisitable
| sqlalchemy.sql.base.SchemaEventTarget
| sqlalchemy.event.registry.EventTarget
| sqlalchemy.sql.visitors.Visitable
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __visit_name__ = 'unique_constraint'
|
| ----------------------------------------------------------------------
| Methods inherited from ColumnCollectionConstraint:
|
| __contains__(self, x: 'Any') -> 'bool'
|
| __init__(self, *columns: '_DDLColumnArgument', name: '_ConstraintNameArgument' = None, deferrable: 'Optional[bool]' = None, initially: 'Optional[str]' = None, info: 'Optional[_InfoType]' = None, _autoattach: 'bool' = True, _column_flag: 'bool' = False, _gather_expressions: 'Optional[List[_DDLColumnArgument]]' = None, **dialect_kw: 'Any') -> 'None'
| :param \*columns:
| A sequence of column names or Column objects.
|
| :param name:
| Optional, the in-database name of this constraint.
|
| :param deferrable:
| Optional bool. If set, emit DEFERRABLE or NOT DEFERRABLE when
| issuing DDL for this constraint.
|
| :param initially:
| Optional string. If set, emit INITIALLY <value> when issuing DDL
| for this constraint.
|
| :param \**dialect_kw: other keyword arguments including
| dialect-specific arguments are propagated to the :class:`.Constraint`
| superclass.
|
| __iter__(self) -> 'Iterator[Column[Any]]'
|
| __len__(self) -> 'int'
|
| contains_column(self, col: 'Column[Any]') -> 'bool'
| Return True if this constraint contains the given column.
|
| Note that this object also contains an attribute ``.columns``
| which is a :class:`_expression.ColumnCollection` of
| :class:`_schema.Column` objects.
|
| copy(self, *, target_table: 'Optional[Table]' = None, **kw: 'Any') -> 'ColumnCollectionConstraint'
| .. deprecated:: 1.4 The :meth:`_schema.ColumnCollectionConstraint.copy` method is deprecated and will be removed in a future release.
|
| ----------------------------------------------------------------------
| Methods inherited from ColumnCollectionMixin:
|
| c(...)
|
| columns(...)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ColumnCollectionMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Constraint:
|
| table
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_options(...)
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| This is a two-level nested registry, keyed to ``<dialect_name>``
| and ``<argument_name>``. For example, the ``postgresql_where``
| argument would be locatable as::
|
| arg = my_object.dialect_options["postgresql"]["where"]
|
| .. versionadded:: 0.9.2
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form
|
| get_dialect_option(self, dialect: 'Dialect', argument_name: 'str', *, else_: 'Any' = None, deprecated_fallback: 'Optional[str]' = None) -> 'Any'
| Return the value of a dialect-specific option, or *else_* if
| this dialect does not register the given argument.
|
| This is useful for DDL compilers that may be inherited by
| third-party dialects whose ``construct_arguments`` do not
| include the same set of keys as the parent dialect.
|
| :param dialect: The dialect for which to retrieve the option.
| :param argument_name: The name of the argument to retrieve.
| :param else\_: The value to return if the argument is not present.
| :param deprecated_fallback: Optional dialect name to fall back to
| if the argument is not present for the current dialect. If the
| argument is present for the fallback dialect but not the current
| dialect, a deprecation warning will be emitted.
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| argument_for(dialect_name: 'str', argument_name: 'str', default: 'Any') -> 'None'
| Add a new kind of dialect-specific keyword argument for this class.
|
| E.g.::
|
| Index.argument_for("mydialect", "length", None)
|
| some_index = Index("a", "b", mydialect_length=5)
|
| The :meth:`.DialectKWArgs.argument_for` method is a per-argument
| way adding extra arguments to the
| :attr:`.DefaultDialect.construct_arguments` dictionary. This
| dictionary provides a list of argument names accepted by various
| schema-level constructs on behalf of a dialect.
|
| New dialects should typically specify this dictionary all at once as a
| data member of the dialect class. The use case for ad-hoc addition of
| argument names is typically for end-user code that is also using
| a custom compilation scheme which consumes the additional arguments.
|
| :param dialect_name: name of a dialect. The dialect must be
| locatable, else a :class:`.NoSuchModuleError` is raised. The
| dialect must also include an existing
| :attr:`.DefaultDialect.construct_arguments` collection, indicating
| that it participates in the keyword-argument validation and default
| system, else :class:`.ArgumentError` is raised. If the dialect does
| not include this collection, then any keyword argument can be
| specified on behalf of this dialect already. All dialects packaged
| within SQLAlchemy include this collection, however for third party
| dialects, support may vary.
|
| :param argument_name: name of the parameter.
|
| :param default: default value of the parameter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from sqlalchemy.sql.base.DialectKWArgs:
|
| dialect_kwargs
| A collection of keyword arguments specified as dialect-specific
| options to this construct.
|
| The arguments are present here in their original ``<dialect>_<kwarg>``
| format. Only arguments that were actually passed are included;
| unlike the :attr:`.DialectKWArgs.dialect_options` collection, which
| contains all options known by this dialect including defaults.
|
| The collection is also writable; keys are accepted of the
| form ``<dialect>_<kwarg>`` where the value will be assembled
| into the list of options.
|
| .. seealso::
|
| :attr:`.DialectKWArgs.dialect_options` - nested dictionary form
|
| kwargs
| A synonym for :attr:`.DialectKWArgs.dialect_kwargs`.
|
| ----------------------------------------------------------------------
| Methods inherited from HasConditionalDDL:
|
| ddl_if(self, dialect: 'Optional[str]' = None, callable_: 'Optional[ddl.DDLIfCallable]' = None, state: 'Optional[Any]' = None) -> 'Self'
| apply a conditional DDL rule to this schema item.
|
| These rules work in a similar manner to the
| :meth:`.ExecutableDDLElement.execute_if` callable, with the added
| feature that the criteria may be checked within the DDL compilation
| phase for a construct such as :class:`.CreateTable`.
| :meth:`.HasConditionalDDL.ddl_if` currently applies towards the
| :class:`.Index` construct as well as all :class:`.Constraint`
| constructs.
|
| :param dialect: string name of a dialect, or a tuple of string names
| to indicate multiple dialect types.
|
| :param callable\_: a callable that is constructed using the same form
| as that described in
| :paramref:`.ExecutableDDLElement.execute_if.callable_`.
|
| :param state: any arbitrary object that will be passed to the
| callable, if present.
|
| .. versionadded:: 2.0
|
| .. seealso::
|
| :ref:`schema_ddl_ddl_if` - background and usage examples
|
| ----------------------------------------------------------------------
| Methods inherited from SchemaItem:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| info(...)
| Info dictionary associated with the object, allowing user-defined
| data to be associated with this :class:`.SchemaItem`.
|
| The dictionary is automatically generated when first accessed.
| It can also be specified in the constructor of some objects,
| such as :class:`_schema.Table` and :class:`_schema.Column`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from SchemaItem:
|
| create_drop_stringify_dialect = 'default'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.base.SchemaEventTarget:
|
| dispatch = <sqlalchemy.event.base.DDLEventsDispatch object>
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.Uuid
Python Library Documentation: class Uuid in module sqlalchemy.sql.sqltypes
class Uuid(sqlalchemy.sql.type_api.Emulated, sqlalchemy.sql.type_api.TypeEngine)
| Uuid(as_uuid: 'bool' = True, native_uuid: 'bool' = True)
|
| Represent a database agnostic UUID datatype.
|
| For backends that have no "native" UUID datatype, the value will
| make use of ``CHAR(32)`` and store the UUID as a 32-character alphanumeric
| hex string.
|
| For backends which are known to support ``UUID`` directly or a similar
| uuid-storing datatype such as SQL Server's ``UNIQUEIDENTIFIER``, a
| "native" mode enabled by default allows these types will be used on those
| backends.
|
| In its default mode of use, the :class:`_sqltypes.Uuid` datatype expects
| **Python uuid objects**, from the Python
| `uuid <https://docs.python.org/3/library/uuid.html>`_
| module::
|
| import uuid
|
| from sqlalchemy import Uuid
| from sqlalchemy import Table, Column, MetaData, String
|
| metadata_obj = MetaData()
|
| t = Table(
| "t",
| metadata_obj,
| Column("uuid_data", Uuid, primary_key=True),
| Column("other_data", String),
| )
|
| with engine.begin() as conn:
| conn.execute(
| t.insert(), {"uuid_data": uuid.uuid4(), "other_data": "some data"}
| )
|
| To have the :class:`_sqltypes.Uuid` datatype work with string-based
| Uuids (e.g. 32 character hexadecimal strings), pass the
| :paramref:`_sqltypes.Uuid.as_uuid` parameter with the value ``False``.
|
| .. versionadded:: 2.0
|
| .. seealso::
|
| :class:`_sqltypes.UUID` - represents exactly the ``UUID`` datatype
| without any backend-agnostic behaviors.
|
| Method resolution order:
| Uuid
| sqlalchemy.sql.type_api.Emulated
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, as_uuid: 'bool' = True, native_uuid: 'bool' = True)
| Construct a :class:`_sqltypes.Uuid` type.
|
| :param as_uuid=True: if True, values will be interpreted
| as Python uuid objects, converting to/from string via the
| DBAPI.
|
| .. versionchanged: 2.0 ``as_uuid`` now defaults to ``True``.
|
| :param native_uuid=True: if True, backends that support either the
| ``UUID`` datatype directly, or a UUID-storing value
| (such as SQL Server's ``UNIQUEIDENTIFIER`` will be used by those
| backends. If False, a ``CHAR(32)`` datatype will be used for
| all backends regardless of native support.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[_UUID_RETURN]]'
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op, value)
| See :meth:`.TypeEngine.coerce_compared_value` for a description.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| native
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'collation': 'Optional[str]', 'length': 'Optional[i...
|
| __parameters__ = ()
|
| __visit_name__ = 'uuid'
|
| collation = None
|
| length = None
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.Emulated:
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
|
| adapt_to_emulated(self, impltype: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| Given an impl class, adapt this type to the impl assuming
| "emulated".
|
| The impl should also be an "emulated" version of this type,
| most likely the same class as this type itself.
|
| e.g.: sqltypes.Enum adapts to the Enum class.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.type_api.Emulated:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| get_dbapi_type(self, dbapi: 'DBAPIModule') -> 'Optional[Any]'
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeEngine.Comparator'>
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| comparator_factory = <class 'sqlalchemy.sql.type_api.TypeEngine.Compar...
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.VARBINARY
Python Library Documentation: class VARBINARY in module sqlalchemy.sql.sqltypes
class VARBINARY(_Binary)
| VARBINARY(length: 'Optional[int]' = None)
|
| The SQL VARBINARY type.
|
| Method resolution order:
| VARBINARY
| _Binary
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'VARBINARY'
|
| ----------------------------------------------------------------------
| Methods inherited from _Binary:
|
| __init__(self, length: 'Optional[int]' = None)
| Initialize self. See help(type(self)) for accurate signature.
|
| bind_processor(self, dialect)
| 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``.
|
| .. tip::
|
| 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.
|
| coerce_compared_value(self, op, value)
| See :meth:`.TypeEngine.coerce_compared_value` for a description.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect, coltype)
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from _Binary:
|
| 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.
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| Comparator = <class 'sqlalchemy.sql.type_api.TypeEngine.Comparator'>
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| comparator_factory = <class 'sqlalchemy.sql.type_api.TypeEngine.Compar...
| Base class for custom comparison operations defined at the
| type level. See :attr:`.TypeEngine.comparator_factory`.
|
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| Function to initialize subclasses.
sqlmodel.VARCHAR
Python Library Documentation: class VARCHAR in module sqlalchemy.sql.sqltypes
class VARCHAR(String)
| VARCHAR(length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
|
| The SQL VARCHAR type.
|
| Method resolution order:
| VARCHAR
| String
| Concatenable
| sqlalchemy.sql.type_api.TypeEngineMixin
| sqlalchemy.sql.type_api.TypeEngine
| sqlalchemy.sql.visitors.Visitable
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __visit_name__ = 'VARCHAR'
|
| ----------------------------------------------------------------------
| Methods inherited from String:
|
| __init__(self, length: 'Optional[int]' = None, collation: 'Optional[str]' = None)
| Create a string-holding type.
|
| :param length: optional, a length for the column for use in
| DDL and CAST expressions. May be safely omitted if no ``CREATE
| TABLE`` will be issued. Certain databases may require a
| ``length`` for use in DDL, and will raise an exception when
| the ``CREATE TABLE`` DDL is issued if a ``VARCHAR``
| with no length is included. Whether the value is
| interpreted as bytes or characters is database specific.
|
| :param collation: Optional, a column-level collation for
| use in DDL and CAST expressions. Renders using the
| COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
| E.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> from sqlalchemy import cast, select, String
| >>> print(select(cast("some string", String(collation="utf8"))))
| {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
|
| .. note::
|
| In most cases, the :class:`.Unicode` or :class:`.UnicodeText`
| datatypes should be used for a :class:`_schema.Column` that expects
| to store non-ascii data. These datatypes will ensure that the
| correct types are used on the database.
|
| bind_processor(self, dialect: 'Dialect') -> 'Optional[_BindProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| get_dbapi_type(self, dbapi)
| Return the corresponding type object from the underlying DB-API, if
| any.
|
| This can be useful for calling ``setinputsizes()``, for example.
|
| literal_processor(self, dialect)
| 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.
|
| .. tip::
|
| 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`
|
| result_processor(self, dialect: 'Dialect', coltype: 'object') -> 'Optional[_ResultProcessorType[str]]'
| 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``.
|
| .. tip::
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from String:
|
| 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.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Concatenable:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Concatenable:
|
| Comparator = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comparator'>
|
| comparator_factory = <class 'sqlalchemy.sql.sqltypes.Concatenable.Comp...
|
| ----------------------------------------------------------------------
| Methods inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __str__(self) -> 'str'
| Return str(self).
|
| adapt(self, cls: 'Type[Union[TypeEngine[Any], TypeEngineMixin]]', **kw: 'Any') -> 'TypeEngine[Any]'
| 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.
|
| as_generic(self, allow_nulltype: 'bool' = False) -> 'TypeEngine[_T]'
| 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.
|
| >>> from sqlalchemy.dialects.mysql import INTEGER
| >>> INTEGER(display_width=4).as_generic()
| Integer()
|
| >>> from sqlalchemy.dialects.mysql import NVARCHAR
| >>> NVARCHAR(length=100).as_generic()
| Unicode(length=100)
|
| .. versionadded:: 1.4.0b2
|
|
| .. seealso::
|
| :ref:`metadata_reflection_dbagnostic_types` - describes the
| use of :meth:`_types.TypeEngine.as_generic` in conjunction with
| the :meth:`_sql.DDLEvents.column_reflect` event, which is its
| intended use.
|
| bind_expression(self, bindvalue: 'BindParameter[_T]') -> 'Optional[ColumnElement[_T]]'
| Given a bind value (i.e. a :class:`.BindParameter` instance),
| return a SQL expression in its place.
|
| This is typically a SQL function that wraps the existing bound
| parameter within the statement. It is used for special data types
| that require literals being wrapped in some special database function
| in order to coerce an application-level value into a database-specific
| format. It is the SQL analogue of the
| :meth:`.TypeEngine.bind_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 that this method, when implemented, should always return
| the exact same structure, without any conditional logic, as it
| may be used in an executemany() call against an arbitrary number
| of bound parameter sets.
|
| .. 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_expression`
| method, unless subclassing the :class:`_types.UserDefinedType`
| class explicitly.
|
| To provide alternate behavior for
| :meth:`_types.TypeEngine.bind_expression`, implement a
| :class:`_types.TypeDecorator` class and provide an implementation
| of :meth:`_types.TypeDecorator.bind_expression`.
|
| .. seealso::
|
| :ref:`types_typedecorator`
|
| .. seealso::
|
| :ref:`types_sql_value_processing`
|
| coerce_compared_value(self, op: 'Optional[OperatorType]', value: 'Any') -> 'TypeEngine[Any]'
| Suggest a type for a 'coerced' Python value in an expression.
|
| Given an operator and value, gives the type a chance
| to return a type which the value should be coerced into.
|
| The default behavior here is conservative; if the right-hand
| side is already coerced into a SQL type based on its
| Python type, it is usually left alone.
|
| End-user functionality extension here should generally be via
| :class:`.TypeDecorator`, which provides more liberal behavior in that
| it defaults to coercing the other side of the expression into this
| type, thus applying special Python conversions above and beyond those
| needed by the DBAPI to both ides. It also provides the public method
| :meth:`.TypeDecorator.coerce_compared_value` which is intended for
| end-user customization of this behavior.
|
| column_expression(self, colexpr: 'ColumnElement[_T]') -> 'Optional[ColumnElement[_T]]'
| 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.
|
| .. note:: The :func:`.TypeEngine.column_expression` method is applied
| only to the **outermost columns clause** of a SELECT statement, that
| is, the columns that are to be delivered directly into the returned
| result rows. It does **not** apply to the columns clause inside
| of subqueries. This necessarily avoids double conversions against
| the column and only runs the conversion when ready to be returned
| to the client.
|
| This method is called during the **SQL compilation** phase of a
| statement, when rendering a SQL string. It is **not** called
| against specific values.
|
| .. tip::
|
| 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`
|
| compare_values(self, x: 'Any', y: 'Any') -> 'bool'
| Compare two values for equality.
|
| compile(self, dialect: 'Optional[Dialect]' = None) -> 'str'
| Produce a string-compiled form of this :class:`.TypeEngine`.
|
| When called with no arguments, uses a "default" dialect
| to produce a string result.
|
| :param dialect: a :class:`.Dialect` instance.
|
| copy(self, **kw: 'Any') -> 'Self'
|
| copy_value(self, value: 'Any') -> 'Any'
|
| dialect_impl(self, dialect: 'Dialect') -> 'TypeEngine[_T]'
| Return a dialect-specific implementation for this
| :class:`.TypeEngine`.
|
| evaluates_none(self) -> 'Self'
| Return a copy of this type which has the
| :attr:`.should_evaluate_none` flag set to True.
|
| E.g.::
|
| Table(
| "some_table",
| metadata,
| Column(
| String(50).evaluates_none(),
| nullable=True,
| server_default="no value",
| ),
| )
|
| The ORM uses this flag to indicate that a positive value of ``None``
| is passed to the column in an INSERT statement, rather than omitting
| the column from the INSERT statement which has the effect of firing
| off column-level defaults. It also allows for types which have
| special behavior associated with the Python None value to indicate
| that the value doesn't necessarily translate into SQL NULL; a
| prime example of this is a JSON type which may wish to persist the
| JSON value ``'null'``.
|
| In all cases, the actual NULL SQL value can be always be
| persisted in any column by using
| the :obj:`_expression.null` SQL construct in an INSERT statement
| or associated with an ORM-mapped attribute.
|
| .. note::
|
| The "evaluates none" flag does **not** apply to a value
| of ``None`` passed to :paramref:`_schema.Column.default` or
| :paramref:`_schema.Column.server_default`; in these cases,
| ``None``
| still means "no default".
|
| .. seealso::
|
| :ref:`session_forcing_null` - in the ORM documentation
|
| :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
| interaction with this flag.
|
| :attr:`.TypeEngine.should_evaluate_none` - class-level flag
|
| with_variant(self, type_: '_TypeEngineArgument[Any]', *dialect_names: 'str') -> 'Self'
| Produce a copy of this type object that will utilize the given
| type when applied to the dialect of the given name.
|
| e.g.::
|
| from sqlalchemy.types import String
| from sqlalchemy.dialects import mysql
|
| string_type = String()
|
| string_type = string_type.with_variant(
| mysql.VARCHAR(collation="foo"), "mysql", "mariadb"
| )
|
| The variant mapping indicates that when this type is
| interpreted by a specific dialect, it will instead be
| transmuted into the given type, rather than using the
| primary type.
|
| .. versionchanged:: 2.0 the :meth:`_types.TypeEngine.with_variant`
| method now works with a :class:`_types.TypeEngine` object "in
| place", returning a copy of the original type rather than returning
| a wrapping object; the ``Variant`` class is no longer used.
|
| :param type\_: a :class:`.TypeEngine` that will be selected
| as a variant from the originating type, when a dialect
| of the given name is in use.
| :param \*dialect_names: one or more base names of the dialect which
| uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)
|
| .. versionchanged:: 2.0 multiple dialect names can be specified
| for one variant.
|
| .. seealso::
|
| :ref:`types_with_variant` - illustrates the use of
| :meth:`_types.TypeEngine.with_variant`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.sql.type_api.TypeEngine:
|
| __orig_bases__ = (<class 'sqlalchemy.sql.visitors.Visitable'>, typing....
|
| hashable = True
|
| render_bind_cast = False
|
| render_literal_cast = False
|
| should_evaluate_none = False
|
| sort_key_function = None
|
| ----------------------------------------------------------------------
| Class methods inherited from sqlalchemy.sql.visitors.Visitable:
|
| __class_getitem__(key: 'Any') -> 'Any'
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__() -> 'None'
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
sqlmodel.alias
Python Library Documentation: function alias in module sqlalchemy.sql._selectable_constructors
alias(selectable: 'FromClause', name: 'Optional[str]' = None, flat: 'bool' = False) -> 'NamedFromClause'
Return a named alias of the given :class:`.FromClause`.
For :class:`.Table` and :class:`.Join` objects, the return type is the
:class:`_expression.Alias` object. Other kinds of :class:`.NamedFromClause`
objects may be returned for other kinds of :class:`.FromClause` objects.
The named alias represents any :class:`_expression.FromClause` with an
alternate name assigned within SQL, typically using the ``AS`` clause when
generated, e.g. ``SELECT * FROM table AS aliasname``.
Equivalent functionality is available via the
:meth:`_expression.FromClause.alias`
method available on all :class:`_expression.FromClause` objects.
:param selectable: any :class:`_expression.FromClause` subclass,
such as a table, select statement, etc.
:param name: string name to be assigned as the alias.
If ``None``, a name will be deterministically generated at compile
time. Deterministic means the name is guaranteed to be unique against
other constructs used in the same statement, and will also be the same
name for each successive compilation of the same statement object.
:param flat: Will be passed through to if the given selectable
is an instance of :class:`_expression.Join` - see
:meth:`_expression.Join.alias` for details.
sqlmodel.all_
Python Library Documentation: function all_ in module sqlmodel.sql.expression
all_(expr: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[~_T], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[~_T], sqlalchemy.sql.roles.TypedColumnsClauseRole[~_T], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), ~_T]) -> sqlalchemy.sql.elements.CollectionAggregate[bool]
sqlmodel.and_
Python Library Documentation: function and_ in module sqlmodel.sql.expression
and_(initial_clause: Union[Literal[True], ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[bool], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[bool], sqlalchemy.sql.roles.TypedColumnsClauseRole[bool], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), bool], *clauses: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[bool], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[bool], sqlalchemy.sql.roles.TypedColumnsClauseRole[bool], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), bool]) -> sqlalchemy.sql.elements.ColumnElement[bool]
sqlmodel.any_
Python Library Documentation: function any_ in module sqlmodel.sql.expression
any_(expr: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[~_T], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[~_T], sqlalchemy.sql.roles.TypedColumnsClauseRole[~_T], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), ~_T]) -> sqlalchemy.sql.elements.CollectionAggregate[bool]
sqlmodel.asc
Python Library Documentation: function asc in module sqlmodel.sql.expression
asc(column: Union[str, ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[~_T], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[~_T], sqlalchemy.sql.roles.TypedColumnsClauseRole[~_T], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), ~_T]) -> sqlalchemy.sql.elements.UnaryExpression[~_T]
sqlmodel.between
Python Library Documentation: function between in module sqlmodel.sql.expression
between(expr: Union[Any, ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[~_T], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[~_T], sqlalchemy.sql.roles.TypedColumnsClauseRole[~_T], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), ~_T], lower_bound: Any, upper_bound: Any, symmetric: bool = False) -> sqlalchemy.sql.elements.BinaryExpression[bool]
sqlmodel.bindparam
Python Library Documentation: function bindparam in module sqlalchemy.sql._elements_constructors
bindparam(key: 'Optional[str]', value: 'Any' = _NoArg.NO_ARG, type_: 'Optional[_TypeEngineArgument[_T]]' = None, unique: 'bool' = False, required: 'Union[bool, Literal[_NoArg.NO_ARG]]' = _NoArg.NO_ARG, quote: 'Optional[bool]' = None, callable_: 'Optional[Callable[[], Any]]' = None, expanding: 'bool' = False, isoutparam: 'bool' = False, literal_execute: 'bool' = False) -> 'BindParameter[_T]'
Produce a "bound expression".
The return value is an instance of :class:`.BindParameter`; this
is a :class:`_expression.ColumnElement`
subclass which represents a so-called
"placeholder" value in a SQL expression, the value of which is
supplied at the point at which the statement in executed against a
database connection.
In SQLAlchemy, the :func:`.bindparam` construct has
the ability to carry along the actual value that will be ultimately
used at expression time. In this way, it serves not just as
a "placeholder" for eventual population, but also as a means of
representing so-called "unsafe" values which should not be rendered
directly in a SQL statement, but rather should be passed along
to the :term:`DBAPI` as values which need to be correctly escaped
and potentially handled for type-safety.
When using :func:`.bindparam` explicitly, the use case is typically
one of traditional deferment of parameters; the :func:`.bindparam`
construct accepts a name which can then be referred to at execution
time::
from sqlalchemy import bindparam
stmt = select(users_table).where(
users_table.c.name == bindparam("username")
)
The above statement, when rendered, will produce SQL similar to:
.. sourcecode:: sql
SELECT id, name FROM user WHERE name = :username
In order to populate the value of ``:username`` above, the value
would typically be applied at execution time to a method
like :meth:`_engine.Connection.execute`::
result = connection.execute(stmt, {"username": "wendy"})
Explicit use of :func:`.bindparam` is also common when producing
UPDATE or DELETE statements that are to be invoked multiple times,
where the WHERE criterion of the statement is to change on each
invocation, such as::
stmt = (
users_table.update()
.where(user_table.c.name == bindparam("username"))
.values(fullname=bindparam("fullname"))
)
connection.execute(
stmt,
[
{"username": "wendy", "fullname": "Wendy Smith"},
{"username": "jack", "fullname": "Jack Jones"},
],
)
SQLAlchemy's Core expression system makes wide use of
:func:`.bindparam` in an implicit sense. It is typical that Python
literal values passed to virtually all SQL expression functions are
coerced into fixed :func:`.bindparam` constructs. For example, given
a comparison operation such as::
expr = users_table.c.name == "Wendy"
The above expression will produce a :class:`.BinaryExpression`
construct, where the left side is the :class:`_schema.Column` object
representing the ``name`` column, and the right side is a
:class:`.BindParameter` representing the literal value::
print(repr(expr.right))
BindParameter("%(4327771088 name)s", "Wendy", type_=String())
The expression above will render SQL such as:
.. sourcecode:: sql
user.name = :name_1
Where the ``:name_1`` parameter name is an anonymous name. The
actual string ``Wendy`` is not in the rendered string, but is carried
along where it is later used within statement execution. If we
invoke a statement like the following::
stmt = select(users_table).where(users_table.c.name == "Wendy")
result = connection.execute(stmt)
We would see SQL logging output as:
.. sourcecode:: sql
SELECT "user".id, "user".name
FROM "user"
WHERE "user".name = %(name_1)s
{'name_1': 'Wendy'}
Above, we see that ``Wendy`` is passed as a parameter to the database,
while the placeholder ``:name_1`` is rendered in the appropriate form
for the target database, in this case the PostgreSQL database.
Similarly, :func:`.bindparam` is invoked automatically when working
with :term:`CRUD` statements as far as the "VALUES" portion is
concerned. The :func:`_expression.insert` construct produces an
``INSERT`` expression which will, at statement execution time, generate
bound placeholders based on the arguments passed, as in::
stmt = users_table.insert()
result = connection.execute(stmt, {"name": "Wendy"})
The above will produce SQL output as:
.. sourcecode:: sql
INSERT INTO "user" (name) VALUES (%(name)s)
{'name': 'Wendy'}
The :class:`_expression.Insert` construct, at
compilation/execution time, rendered a single :func:`.bindparam`
mirroring the column name ``name`` as a result of the single ``name``
parameter we passed to the :meth:`_engine.Connection.execute` method.
:param key:
the key (e.g. the name) for this bind param.
Will be used in the generated
SQL statement for dialects that use named parameters. This
value may be modified when part of a compilation operation,
if other :class:`BindParameter` objects exist with the same
key, or if its length is too long and truncation is
required.
If omitted, an "anonymous" name is generated for the bound parameter;
when given a value to bind, the end result is equivalent to calling upon
the :func:`.literal` function with a value to bind, particularly
if the :paramref:`.bindparam.unique` parameter is also provided.
:param value:
Initial value for this bind param. Will be used at statement
execution time as the value for this parameter passed to the
DBAPI, if no other value is indicated to the statement execution
method for this particular parameter name. Defaults to ``None``.
:param callable\_:
A callable function that takes the place of "value". The function
will be called at statement execution time to determine the
ultimate value. Used for scenarios where the actual bind
value cannot be determined at the point at which the clause
construct is created, but embedded bind values are still desirable.
:param type\_:
A :class:`.TypeEngine` class or instance representing an optional
datatype for this :func:`.bindparam`. If not passed, a type
may be determined automatically for the bind, based on the given
value; for example, trivial Python types such as ``str``,
``int``, ``bool``
may result in the :class:`.String`, :class:`.Integer` or
:class:`.Boolean` types being automatically selected.
The type of a :func:`.bindparam` is significant especially in that
the type will apply pre-processing to the value before it is
passed to the database. For example, a :func:`.bindparam` which
refers to a datetime value, and is specified as holding the
:class:`.DateTime` type, may apply conversion needed to the
value (such as stringification on SQLite) before passing the value
to the database.
:param unique:
if True, the key name of this :class:`.BindParameter` will be
modified if another :class:`.BindParameter` of the same name
already has been located within the containing
expression. This flag is used generally by the internals
when producing so-called "anonymous" bound expressions, it
isn't generally applicable to explicitly-named :func:`.bindparam`
constructs.
:param required:
If ``True``, a value is required at execution time. If not passed,
it defaults to ``True`` if neither :paramref:`.bindparam.value`
or :paramref:`.bindparam.callable` were passed. If either of these
parameters are present, then :paramref:`.bindparam.required`
defaults to ``False``.
:param quote:
True if this parameter name requires quoting and is not
currently known as a SQLAlchemy reserved word; this currently
only applies to the Oracle Database backends, where bound names must
sometimes be quoted.
:param isoutparam:
if True, the parameter should be treated like a stored procedure
"OUT" parameter. This applies to backends such as Oracle Database which
support OUT parameters.
:param expanding:
if True, this parameter will be treated as an "expanding" parameter
at execution time; the parameter value is expected to be a sequence,
rather than a scalar value, and the string SQL statement will
be transformed on a per-execution basis to accommodate the sequence
with a variable number of parameter slots passed to the DBAPI.
This is to allow statement caching to be used in conjunction with
an IN clause.
.. seealso::
:meth:`.ColumnOperators.in_`
:ref:`baked_in` - with baked queries
.. note:: The "expanding" feature does not support "executemany"-
style parameter sets.
.. versionadded:: 1.2
.. versionchanged:: 1.3 the "expanding" bound parameter feature now
supports empty lists.
:param literal_execute:
if True, the bound parameter will be rendered in the compile phase
with a special "POSTCOMPILE" token, and the SQLAlchemy compiler will
render the final value of the parameter into the SQL statement at
statement execution time, omitting the value from the parameter
dictionary / list passed to DBAPI ``cursor.execute()``. This
produces a similar effect as that of using the ``literal_binds``,
compilation flag, however takes place as the statement is sent to
the DBAPI ``cursor.execute()`` method, rather than when the statement
is compiled. The primary use of this
capability is for rendering LIMIT / OFFSET clauses for database
drivers that can't accommodate for bound parameters in these
contexts, while allowing SQL constructs to be cacheable at the
compilation level.
.. versionadded:: 1.4 Added "post compile" bound parameters
.. seealso::
:ref:`change_4808`.
.. seealso::
:ref:`tutorial_sending_parameters` - in the
:ref:`unified_tutorial`
sqlmodel.case
Python Library Documentation: function case in module sqlmodel.sql.expression
case(*whens: tuple[typing.Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[bool], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[bool], sqlalchemy.sql.roles.TypedColumnsClauseRole[bool], typing.Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), bool], typing.Any] | collections.abc.Mapping[typing.Any, typing.Any], value: typing.Any | None = None, else_: typing.Any | None = None) -> sqlalchemy.sql.elements.Case[typing.Any]
sqlmodel.cast
Python Library Documentation: function cast in module sqlmodel.sql.expression
cast(expression: Union[Any, ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[Any], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[Any], sqlalchemy.sql.roles.TypedColumnsClauseRole[Any], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement')], type_: '_TypeEngineArgument[_T]') -> sqlalchemy.sql.elements.Cast[~_T]
sqlmodel.col
Python Library Documentation: function col in module sqlmodel.sql.expression col(column_expression: ~_T) -> sqlalchemy.orm.base.Mapped[~_T]
sqlmodel.collate
Python Library Documentation: function collate in module sqlmodel.sql.expression
collate(expression: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[str], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[str], sqlalchemy.sql.roles.TypedColumnsClauseRole[str], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), str], collation: str) -> sqlalchemy.sql.elements.BinaryExpression[str]
sqlmodel.column
Python Library Documentation: function column in module sqlalchemy.sql._elements_constructors
column(text: 'str', type_: 'Optional[_TypeEngineArgument[_T]]' = None, is_literal: 'bool' = False, _selectable: 'Optional[FromClause]' = None) -> 'ColumnClause[_T]'
Produce a :class:`.ColumnClause` object.
The :class:`.ColumnClause` is a lightweight analogue to the
:class:`_schema.Column` class. The :func:`_expression.column`
function can
be invoked with just a name alone, as in::
from sqlalchemy import column
id, name = column("id"), column("name")
stmt = select(id, name).select_from("user")
The above statement would produce SQL like:
.. sourcecode:: sql
SELECT id, name FROM user
Once constructed, :func:`_expression.column`
may be used like any other SQL
expression element such as within :func:`_expression.select`
constructs::
from sqlalchemy.sql import column
id, name = column("id"), column("name")
stmt = select(id, name).select_from("user")
The text handled by :func:`_expression.column`
is assumed to be handled
like the name of a database column; if the string contains mixed case,
special characters, or matches a known reserved word on the target
backend, the column expression will render using the quoting
behavior determined by the backend. To produce a textual SQL
expression that is rendered exactly without any quoting,
use :func:`_expression.literal_column` instead,
or pass ``True`` as the
value of :paramref:`_expression.column.is_literal`. Additionally,
full SQL
statements are best handled using the :func:`_expression.text`
construct.
:func:`_expression.column` can be used in a table-like
fashion by combining it with the :func:`.table` function
(which is the lightweight analogue to :class:`_schema.Table`
) to produce
a working table construct with minimal boilerplate::
from sqlalchemy import table, column, select
user = table(
"user",
column("id"),
column("name"),
column("description"),
)
stmt = select(user.c.description).where(user.c.name == "wendy")
A :func:`_expression.column` / :func:`.table`
construct like that illustrated
above can be created in an
ad-hoc fashion and is not associated with any
:class:`_schema.MetaData`, DDL, or events, unlike its
:class:`_schema.Table` counterpart.
:param text: the text of the element.
:param type: :class:`_types.TypeEngine` object which can associate
this :class:`.ColumnClause` with a type.
:param is_literal: if True, the :class:`.ColumnClause` is assumed to
be an exact expression that will be delivered to the output with no
quoting rules applied regardless of case sensitive settings. the
:func:`_expression.literal_column()` function essentially invokes
:func:`_expression.column` while passing ``is_literal=True``.
.. seealso::
:class:`_schema.Column`
:func:`_expression.literal_column`
:func:`.table`
:func:`_expression.text`
:ref:`tutorial_select_arbitrary_text`
sqlmodel.create_engine
Python Library Documentation: function create_engine in module sqlalchemy.engine.create
create_engine(url: 'Union[str, _url.URL]', **kwargs: 'Any') -> 'Engine'
Create a new :class:`_engine.Engine` instance.
The standard calling form is to send the :ref:`URL <database_urls>` as the
first positional argument, usually a string
that indicates database dialect and connection arguments::
engine = create_engine("postgresql+psycopg2://scott:tiger@localhost/test")
.. note::
Please review :ref:`database_urls` for general guidelines in composing
URL strings. In particular, special characters, such as those often
part of passwords, must be URL encoded to be properly parsed.
Additional keyword arguments may then follow it which
establish various options on the resulting :class:`_engine.Engine`
and its underlying :class:`.Dialect` and :class:`_pool.Pool`
constructs::
engine = create_engine(
"mysql+mysqldb://scott:tiger@hostname/dbname",
pool_recycle=3600,
echo=True,
)
The string form of the URL is
``dialect[+driver]://user:password@host/dbname[?key=value..]``, where
``dialect`` is a database name such as ``mysql``, ``oracle``,
``postgresql``, etc., and ``driver`` the name of a DBAPI, such as
``psycopg2``, ``pyodbc``, ``cx_oracle``, etc. Alternatively,
the URL can be an instance of :class:`~sqlalchemy.engine.url.URL`.
``**kwargs`` takes a wide variety of options which are routed
towards their appropriate components. Arguments may be specific to
the :class:`_engine.Engine`, the underlying :class:`.Dialect`,
as well as the
:class:`_pool.Pool`. Specific dialects also accept keyword arguments that
are unique to that dialect. Here, we describe the parameters
that are common to most :func:`_sa.create_engine()` usage.
Once established, the newly resulting :class:`_engine.Engine` will
request a connection from the underlying :class:`_pool.Pool` once
:meth:`_engine.Engine.connect` is called, or a method which depends on it
such as :meth:`_engine.Engine.execute` is invoked. The
:class:`_pool.Pool` in turn
will establish the first actual DBAPI connection when this request
is received. The :func:`_sa.create_engine` call itself does **not**
establish any actual DBAPI connections directly.
.. seealso::
:doc:`/core/engines`
:doc:`/dialects/index`
:ref:`connections_toplevel`
:param connect_args: a dictionary of options which will be
passed directly to the DBAPI's ``connect()`` method as
additional keyword arguments. See the example
at :ref:`custom_dbapi_args`.
:param creator: a callable which returns a DBAPI connection.
This creation function will be passed to the underlying
connection pool and will be used to create all new database
connections. Usage of this function causes connection
parameters specified in the URL argument to be bypassed.
This hook is not as flexible as the newer
:meth:`_events.DialectEvents.do_connect` hook which allows complete
control over how a connection is made to the database, given the full
set of URL arguments and state beforehand.
.. seealso::
:meth:`_events.DialectEvents.do_connect` - event hook that allows
full control over DBAPI connection mechanics.
:ref:`custom_dbapi_args`
:param echo=False: if True, the Engine will log all statements
as well as a ``repr()`` of their parameter lists to the default log
handler, which defaults to ``sys.stdout`` for output. If set to the
string ``"debug"``, result rows will be printed to the standard output
as well. The ``echo`` attribute of ``Engine`` can be modified at any
time to turn logging on and off; direct control of logging is also
available using the standard Python ``logging`` module.
.. seealso::
:ref:`dbengine_logging` - further detail on how to configure
logging.
:param echo_pool=False: if True, the connection pool will log
informational output such as when connections are invalidated
as well as when connections are recycled to the default log handler,
which defaults to ``sys.stdout`` for output. If set to the string
``"debug"``, the logging will include pool checkouts and checkins.
Direct control of logging is also available using the standard Python
``logging`` module.
.. seealso::
:ref:`dbengine_logging` - further detail on how to configure
logging.
:param empty_in_strategy: No longer used; SQLAlchemy now uses
"empty set" behavior for IN in all cases.
.. deprecated:: 1.4 The :paramref:`_sa.create_engine.empty_in_strategy` keyword is deprecated, and no longer has any effect. All IN expressions are now rendered using the "expanding parameter" strategy which renders a set of boundexpressions, or an "empty set" SELECT, at statement executiontime.
:param enable_from_linting: defaults to True. Will emit a warning
if a given SELECT statement is found to have un-linked FROM elements
which would cause a cartesian product.
.. versionadded:: 1.4
.. seealso::
:ref:`change_4737`
:param execution_options: Dictionary execution options which will
be applied to all connections. See
:meth:`~sqlalchemy.engine.Connection.execution_options`
:param future: Use the 2.0 style :class:`_engine.Engine` and
:class:`_engine.Connection` API.
As of SQLAlchemy 2.0, this parameter is present for backwards
compatibility only and must remain at its default value of ``True``.
The :paramref:`_sa.create_engine.future` parameter will be
deprecated in a subsequent 2.x release and eventually removed.
.. versionadded:: 1.4
.. versionchanged:: 2.0 All :class:`_engine.Engine` objects are
"future" style engines and there is no longer a ``future=False``
mode of operation.
.. seealso::
:ref:`migration_20_toplevel`
:param hide_parameters: Boolean, when set to True, SQL statement parameters
will not be displayed in INFO logging nor will they be formatted into
the string representation of :class:`.StatementError` objects.
.. versionadded:: 1.3.8
.. seealso::
:ref:`dbengine_logging` - further detail on how to configure
logging.
:param implicit_returning=True: Legacy parameter that may only be set
to True. In SQLAlchemy 2.0, this parameter does nothing. In order to
disable "implicit returning" for statements invoked by the ORM,
configure this on a per-table basis using the
:paramref:`.Table.implicit_returning` parameter.
:param insertmanyvalues_page_size: number of rows to format into an
INSERT statement when the statement uses "insertmanyvalues" mode, which is
a paged form of bulk insert that is used for many backends when using
:term:`executemany` execution typically in conjunction with RETURNING.
Defaults to 1000, but may also be subject to dialect-specific limiting
factors which may override this value on a per-statement basis.
.. versionadded:: 2.0
.. seealso::
:ref:`engine_insertmanyvalues`
:ref:`engine_insertmanyvalues_page_size`
:paramref:`_engine.Connection.execution_options.insertmanyvalues_page_size`
:param isolation_level: optional string name of an isolation level
which will be set on all new connections unconditionally.
Isolation levels are typically some subset of the string names
``"SERIALIZABLE"``, ``"REPEATABLE READ"``,
``"READ COMMITTED"``, ``"READ UNCOMMITTED"`` and ``"AUTOCOMMIT"``
based on backend.
The :paramref:`_sa.create_engine.isolation_level` parameter is
in contrast to the
:paramref:`.Connection.execution_options.isolation_level`
execution option, which may be set on an individual
:class:`.Connection`, as well as the same parameter passed to
:meth:`.Engine.execution_options`, where it may be used to create
multiple engines with different isolation levels that share a common
connection pool and dialect.
.. versionchanged:: 2.0 The
:paramref:`_sa.create_engine.isolation_level`
parameter has been generalized to work on all dialects which support
the concept of isolation level, and is provided as a more succinct,
up front configuration switch in contrast to the execution option
which is more of an ad-hoc programmatic option.
.. seealso::
:ref:`dbapi_autocommit`
:param json_deserializer: for dialects that support the
:class:`_types.JSON`
datatype, this is a Python callable that will convert a JSON string
to a Python object. By default, the Python ``json.loads`` function is
used.
.. versionchanged:: 1.3.7 The SQLite dialect renamed this from
``_json_deserializer``.
:param json_serializer: for dialects that support the :class:`_types.JSON`
datatype, this is a Python callable that will render a given object
as JSON. By default, the Python ``json.dumps`` function is used.
.. versionchanged:: 1.3.7 The SQLite dialect renamed this from
``_json_serializer``.
:param label_length=None: optional integer value which limits
the size of dynamically generated column labels to that many
characters. If less than 6, labels are generated as
"_(counter)". If ``None``, the value of
``dialect.max_identifier_length``, which may be affected via the
:paramref:`_sa.create_engine.max_identifier_length` parameter,
is used instead. The value of
:paramref:`_sa.create_engine.label_length`
may not be larger than that of
:paramref:`_sa.create_engine.max_identfier_length`.
.. seealso::
:paramref:`_sa.create_engine.max_identifier_length`
:param logging_name: String identifier which will be used within
the "name" field of logging records generated within the
"sqlalchemy.engine" logger. Defaults to a hexstring of the
object's id.
.. seealso::
:ref:`dbengine_logging` - further detail on how to configure
logging.
:paramref:`_engine.Connection.execution_options.logging_token`
:param max_identifier_length: integer; override the max_identifier_length
determined by the dialect. if ``None`` or zero, has no effect. This
is the database's configured maximum number of characters that may be
used in a SQL identifier such as a table name, column name, or label
name. All dialects determine this value automatically, however in the
case of a new database version for which this value has changed but
SQLAlchemy's dialect has not been adjusted, the value may be passed
here.
.. versionadded:: 1.3.9
.. seealso::
:paramref:`_sa.create_engine.label_length`
:param max_overflow=10: the number of connections to allow in
connection pool "overflow", that is connections that can be
opened above and beyond the pool_size setting, which defaults
to five. this is only used with :class:`~sqlalchemy.pool.QueuePool`.
:param module=None: reference to a Python module object (the module
itself, not its string name). Specifies an alternate DBAPI module to
be used by the engine's dialect. Each sub-dialect references a
specific DBAPI which will be imported before first connect. This
parameter causes the import to be bypassed, and the given module to
be used instead. Can be used for testing of DBAPIs as well as to
inject "mock" DBAPI implementations into the :class:`_engine.Engine`.
:param paramstyle=None: The `paramstyle <https://legacy.python.org/dev/peps/pep-0249/#paramstyle>`_
to use when rendering bound parameters. This style defaults to the
one recommended by the DBAPI itself, which is retrieved from the
``.paramstyle`` attribute of the DBAPI. However, most DBAPIs accept
more than one paramstyle, and in particular it may be desirable
to change a "named" paramstyle into a "positional" one, or vice versa.
When this attribute is passed, it should be one of the values
``"qmark"``, ``"numeric"``, ``"named"``, ``"format"`` or
``"pyformat"``, and should correspond to a parameter style known
to be supported by the DBAPI in use.
:param pool=None: an already-constructed instance of
:class:`~sqlalchemy.pool.Pool`, such as a
:class:`~sqlalchemy.pool.QueuePool` instance. If non-None, this
pool will be used directly as the underlying connection pool
for the engine, bypassing whatever connection parameters are
present in the URL argument. For information on constructing
connection pools manually, see :ref:`pooling_toplevel`.
:param poolclass=None: a :class:`~sqlalchemy.pool.Pool`
subclass, which will be used to create a connection pool
instance using the connection parameters given in the URL. Note
this differs from ``pool`` in that you don't actually
instantiate the pool in this case, you just indicate what type
of pool to be used.
:param pool_logging_name: String identifier which will be used within
the "name" field of logging records generated within the
"sqlalchemy.pool" logger. Defaults to a hexstring of the object's
id.
.. seealso::
:ref:`dbengine_logging` - further detail on how to configure
logging.
:param pool_pre_ping: boolean, if True will enable the connection pool
"pre-ping" feature that tests connections for liveness upon
each checkout.
.. versionadded:: 1.2
.. seealso::
:ref:`pool_disconnects_pessimistic`
:param pool_size=5: the number of connections to keep open
inside the connection pool. This used with
:class:`~sqlalchemy.pool.QueuePool` as
well as :class:`~sqlalchemy.pool.SingletonThreadPool`. With
:class:`~sqlalchemy.pool.QueuePool`, a ``pool_size`` setting
of 0 indicates no limit; to disable pooling, set ``poolclass`` to
:class:`~sqlalchemy.pool.NullPool` instead.
:param pool_recycle=-1: this setting causes the pool to recycle
connections after the given number of seconds has passed. It
defaults to -1, or no timeout. For example, setting to 3600
means connections will be recycled after one hour. Note that
MySQL in particular will disconnect automatically if no
activity is detected on a connection for eight hours (although
this is configurable with the MySQLDB connection itself and the
server configuration as well).
.. seealso::
:ref:`pool_setting_recycle`
:param pool_reset_on_return='rollback': set the
:paramref:`_pool.Pool.reset_on_return` parameter of the underlying
:class:`_pool.Pool` object, which can be set to the values
``"rollback"``, ``"commit"``, or ``None``.
.. seealso::
:ref:`pool_reset_on_return`
:ref:`dbapi_autocommit_skip_rollback` - a more modern approach
to using connections with no transactional instructions
:param pool_timeout=30: number of seconds to wait before giving
up on getting a connection from the pool. This is only used
with :class:`~sqlalchemy.pool.QueuePool`. This can be a float but is
subject to the limitations of Python time functions which may not be
reliable in the tens of milliseconds.
.. note: don't use 30.0 above, it seems to break with the :param tag
:param pool_use_lifo=False: use LIFO (last-in-first-out) when retrieving
connections from :class:`.QueuePool` instead of FIFO
(first-in-first-out). Using LIFO, a server-side timeout scheme can
reduce the number of connections used during non- peak periods of
use. When planning for server-side timeouts, ensure that a recycle or
pre-ping strategy is in use to gracefully handle stale connections.
.. versionadded:: 1.3
.. seealso::
:ref:`pool_use_lifo`
:ref:`pool_disconnects`
:param plugins: string list of plugin names to load. See
:class:`.CreateEnginePlugin` for background.
.. versionadded:: 1.2.3
:param query_cache_size: size of the cache used to cache the SQL string
form of queries. Set to zero to disable caching.
The cache is pruned of its least recently used items when its size reaches
N * 1.5. Defaults to 500, meaning the cache will always store at least
500 SQL statements when filled, and will grow up to 750 items at which
point it is pruned back down to 500 by removing the 250 least recently
used items.
Caching is accomplished on a per-statement basis by generating a
cache key that represents the statement's structure, then generating
string SQL for the current dialect only if that key is not present
in the cache. All statements support caching, however some features
such as an INSERT with a large set of parameters will intentionally
bypass the cache. SQL logging will indicate statistics for each
statement whether or not it were pull from the cache.
.. note:: some ORM functions related to unit-of-work persistence as well
as some attribute loading strategies will make use of individual
per-mapper caches outside of the main cache.
.. seealso::
:ref:`sql_caching`
.. versionadded:: 1.4
:param skip_autocommit_rollback: When True, the dialect will
unconditionally skip all calls to the DBAPI ``connection.rollback()``
method if the DBAPI connection is confirmed to be in "autocommit" mode.
The availability of this feature is dialect specific; if not available,
a ``NotImplementedError`` is raised by the dialect when rollback occurs.
.. seealso::
:ref:`dbapi_autocommit_skip_rollback`
.. versionadded:: 2.0.43
:param use_insertmanyvalues: True by default, use the "insertmanyvalues"
execution style for INSERT..RETURNING statements by default.
.. versionadded:: 2.0
.. seealso::
:ref:`engine_insertmanyvalues`
sqlmodel.create_mock_engine
Python Library Documentation: function create_mock_engine in module sqlalchemy.engine.mock
create_mock_engine(url: 'Union[str, URL]', executor: 'Any', **kw: 'Any') -> 'MockConnection'
Create a "mock" engine used for echoing DDL.
This is a utility function used for debugging or storing the output of DDL
sequences as generated by :meth:`_schema.MetaData.create_all`
and related methods.
The function accepts a URL which is used only to determine the kind of
dialect to be used, as well as an "executor" callable function which
will receive a SQL expression object and parameters, which can then be
echoed or otherwise printed. The executor's return value is not handled,
nor does the engine allow regular string statements to be invoked, and
is therefore only useful for DDL that is sent to the database without
receiving any results.
E.g.::
from sqlalchemy import create_mock_engine
def dump(sql, *multiparams, **params):
print(sql.compile(dialect=engine.dialect))
engine = create_mock_engine("postgresql+psycopg2://", dump)
metadata.create_all(engine, checkfirst=False)
:param url: A string URL which typically needs to contain only the
database backend name.
:param executor: a callable which receives the arguments ``sql``,
``*multiparams`` and ``**params``. The ``sql`` parameter is typically
an instance of :class:`.ExecutableDDLElement`, which can then be compiled
into a string using :meth:`.ExecutableDDLElement.compile`.
.. versionadded:: 1.4 - the :func:`.create_mock_engine` function replaces
the previous "mock" engine strategy used with
:func:`_sa.create_engine`.
.. seealso::
:ref:`faq_ddl_as_string`
sqlmodel.delete
Python Library Documentation: function delete in module sqlalchemy.sql._dml_constructors
delete(table: '_DMLTableArgument') -> 'Delete'
Construct :class:`_expression.Delete` object.
E.g.::
from sqlalchemy import delete
stmt = delete(user_table).where(user_table.c.id == 5)
Similar functionality is available via the
:meth:`_expression.TableClause.delete` method on
:class:`_schema.Table`.
:param table: The table to delete rows from.
.. seealso::
:ref:`tutorial_core_update_delete` - in the :ref:`unified_tutorial`
sqlmodel.desc
Python Library Documentation: function desc in module sqlmodel.sql.expression
desc(column: Union[str, ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[~_T], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[~_T], sqlalchemy.sql.roles.TypedColumnsClauseRole[~_T], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), ~_T]) -> sqlalchemy.sql.elements.UnaryExpression[~_T]
sqlmodel.distinct
Python Library Documentation: function distinct in module sqlmodel.sql.expression
distinct(expr: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[~_T], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[~_T], sqlalchemy.sql.roles.TypedColumnsClauseRole[~_T], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), ~_T]) -> sqlalchemy.sql.elements.UnaryExpression[~_T]
sqlmodel.engine_from_config
Python Library Documentation: function engine_from_config in module sqlalchemy.engine.create
engine_from_config(configuration: 'Dict[str, Any]', prefix: 'str' = 'sqlalchemy.', **kwargs: 'Any') -> 'Engine'
Create a new Engine instance using a configuration dictionary.
The dictionary is typically produced from a config file.
The keys of interest to ``engine_from_config()`` should be prefixed, e.g.
``sqlalchemy.url``, ``sqlalchemy.echo``, etc. The 'prefix' argument
indicates the prefix to be searched for. Each matching key (after the
prefix is stripped) is treated as though it were the corresponding keyword
argument to a :func:`_sa.create_engine` call.
The only required key is (assuming the default prefix) ``sqlalchemy.url``,
which provides the :ref:`database URL <database_urls>`.
A select set of keyword arguments will be "coerced" to their
expected type based on string values. The set of arguments
is extensible per-dialect using the ``engine_config_types`` accessor.
:param configuration: A dictionary (typically produced from a config file,
but this is not a requirement). Items whose keys start with the value
of 'prefix' will have that prefix stripped, and will then be passed to
:func:`_sa.create_engine`.
:param prefix: Prefix to match and then strip from keys
in 'configuration'.
:param kwargs: Each keyword argument to ``engine_from_config()`` itself
overrides the corresponding item taken from the 'configuration'
dictionary. Keyword arguments should *not* be prefixed.
sqlmodel.except_
Python Library Documentation: function except_ in module sqlalchemy.sql._selectable_constructors
except_(*selects: '_SelectStatementForCompoundArgument[_TP]') -> 'CompoundSelect[_TP]'
Return an ``EXCEPT`` of multiple selectables.
The returned object is an instance of
:class:`_expression.CompoundSelect`.
:param \*selects:
a list of :class:`_expression.Select` instances.
sqlmodel.except_all
Python Library Documentation: function except_all in module sqlalchemy.sql._selectable_constructors
except_all(*selects: '_SelectStatementForCompoundArgument[_TP]') -> 'CompoundSelect[_TP]'
Return an ``EXCEPT ALL`` of multiple selectables.
The returned object is an instance of
:class:`_expression.CompoundSelect`.
:param \*selects:
a list of :class:`_expression.Select` instances.
sqlmodel.exists
Python Library Documentation: function exists in module sqlalchemy.sql._selectable_constructors
exists(__argument: 'Optional[Union[_ColumnsClauseArgument[Any], SelectBase, ScalarSelect[Any]]]' = None) -> 'Exists'
Construct a new :class:`_expression.Exists` construct.
The :func:`_sql.exists` can be invoked by itself to produce an
:class:`_sql.Exists` construct, which will accept simple WHERE
criteria::
exists_criteria = exists().where(table1.c.col1 == table2.c.col2)
However, for greater flexibility in constructing the SELECT, an
existing :class:`_sql.Select` construct may be converted to an
:class:`_sql.Exists`, most conveniently by making use of the
:meth:`_sql.SelectBase.exists` method::
exists_criteria = (
select(table2.c.col2).where(table1.c.col1 == table2.c.col2).exists()
)
The EXISTS criteria is then used inside of an enclosing SELECT::
stmt = select(table1.c.col1).where(exists_criteria)
The above statement will then be of the form:
.. sourcecode:: sql
SELECT col1 FROM table1 WHERE EXISTS
(SELECT table2.col2 FROM table2 WHERE table2.col2 = table1.col1)
.. seealso::
:ref:`tutorial_exists` - in the :term:`2.0 style` tutorial.
:meth:`_sql.SelectBase.exists` - method to transform a ``SELECT`` to an
``EXISTS`` clause.
sqlmodel.extract
Python Library Documentation: function extract in module sqlmodel.sql.expression
extract(field: str, expr: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[Any], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[Any], sqlalchemy.sql.roles.TypedColumnsClauseRole[Any], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), Any]) -> sqlalchemy.sql.elements.Extract
sqlmodel.false
Python Library Documentation: function false in module sqlalchemy.sql._elements_constructors
false() -> 'False_'
Return a :class:`.False_` construct.
E.g.:
.. sourcecode:: pycon+sql
>>> from sqlalchemy import false
>>> print(select(t.c.x).where(false()))
{printsql}SELECT x FROM t WHERE false
A backend which does not support true/false constants will render as
an expression against 1 or 0:
.. sourcecode:: pycon+sql
>>> print(select(t.c.x).where(false()))
{printsql}SELECT x FROM t WHERE 0 = 1
The :func:`.true` and :func:`.false` constants also feature
"short circuit" operation within an :func:`.and_` or :func:`.or_`
conjunction:
.. sourcecode:: pycon+sql
>>> print(select(t.c.x).where(or_(t.c.x > 5, true())))
{printsql}SELECT x FROM t WHERE true{stop}
>>> print(select(t.c.x).where(and_(t.c.x > 5, false())))
{printsql}SELECT x FROM t WHERE false{stop}
.. seealso::
:func:`.true`
sqlmodel.func
Python Library Documentation: _FunctionGenerator in module sqlalchemy.sql.functions object
class _FunctionGenerator(builtins.object)
| _FunctionGenerator(**opts: 'Any') -> 'None'
|
| Generate SQL function expressions.
|
| :data:`.func` is a special object instance which generates SQL
| functions based on name-based attributes, e.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> print(func.count(1))
| {printsql}count(:param_1)
|
| The returned object is an instance of :class:`.Function`, and is a
| column-oriented SQL element like any other, and is used in that way:
|
| .. sourcecode:: pycon+sql
|
| >>> print(select(func.count(table.c.id)))
| {printsql}SELECT count(sometable.id) FROM sometable
|
| Any name can be given to :data:`.func`. If the function name is unknown to
| SQLAlchemy, it will be rendered exactly as is. For common SQL functions
| which SQLAlchemy is aware of, the name may be interpreted as a *generic
| function* which will be compiled appropriately to the target database:
|
| .. sourcecode:: pycon+sql
|
| >>> print(func.current_timestamp())
| {printsql}CURRENT_TIMESTAMP
|
| To call functions which are present in dot-separated packages,
| specify them in the same manner:
|
| .. sourcecode:: pycon+sql
|
| >>> print(func.stats.yield_curve(5, 10))
| {printsql}stats.yield_curve(:yield_curve_1, :yield_curve_2)
|
| SQLAlchemy can be made aware of the return type of functions to enable
| type-specific lexical and result-based behavior. For example, to ensure
| that a string-based function returns a Unicode value and is similarly
| treated as a string in expressions, specify
| :class:`~sqlalchemy.types.Unicode` as the type:
|
| .. sourcecode:: pycon+sql
|
| >>> print(
| ... func.my_string("hi", type_=Unicode)
| ... + " "
| ... + func.my_string("there", type_=Unicode)
| ... )
| {printsql}my_string(:my_string_1) || :my_string_2 || my_string(:my_string_3)
|
| The object returned by a :data:`.func` call is usually an instance of
| :class:`.Function`.
| This object meets the "column" interface, including comparison and labeling
| functions. The object can also be passed the :meth:`~.Connectable.execute`
| method of a :class:`_engine.Connection` or :class:`_engine.Engine`,
| where it will be
| wrapped inside of a SELECT statement first::
|
| print(connection.execute(func.current_timestamp()).scalar())
|
| In a few exception cases, the :data:`.func` accessor
| will redirect a name to a built-in expression such as :func:`.cast`
| or :func:`.extract`, as these names have well-known meaning
| but are not exactly the same as "functions" from a SQLAlchemy
| perspective.
|
| Functions which are interpreted as "generic" functions know how to
| calculate their return type automatically. For a listing of known generic
| functions, see :ref:`generic_functions`.
|
| .. note::
|
| The :data:`.func` construct has only limited support for calling
| standalone "stored procedures", especially those with special
| parameterization concerns.
|
| See the section :ref:`stored_procedures` for details on how to use
| the DBAPI-level ``callproc()`` method for fully traditional stored
| procedures.
|
| .. seealso::
|
| :ref:`tutorial_functions` - in the :ref:`unified_tutorial`
|
| :class:`.Function`
|
| Methods defined here:
|
| __call__(self, *c: 'Any', **kwargs: 'Any') -> 'Function[Any]'
| Call self as a function.
|
| __getattr__(self, name: 'str') -> '_FunctionGenerator'
|
| __init__(self, **opts: 'Any') -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
sqlmodel.funcfilter
Python Library Documentation: function funcfilter in module sqlmodel.sql.expression
funcfilter(func: sqlalchemy.sql.functions.FunctionElement[~_T], *criterion: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[bool], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[bool], sqlalchemy.sql.roles.TypedColumnsClauseRole[bool], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), bool]) -> sqlalchemy.sql.elements.FunctionFilter[~_T]
sqlmodel.insert
Python Library Documentation: function insert in module sqlalchemy.sql._dml_constructors
insert(table: '_DMLTableArgument') -> 'Insert'
Construct an :class:`_expression.Insert` object.
E.g.::
from sqlalchemy import insert
stmt = insert(user_table).values(name="username", fullname="Full Username")
Similar functionality is available via the
:meth:`_expression.TableClause.insert` method on
:class:`_schema.Table`.
.. seealso::
:ref:`tutorial_core_insert` - in the :ref:`unified_tutorial`
:param table: :class:`_expression.TableClause`
which is the subject of the
insert.
:param values: collection of values to be inserted; see
:meth:`_expression.Insert.values`
for a description of allowed formats here.
Can be omitted entirely; a :class:`_expression.Insert` construct
will also dynamically render the VALUES clause at execution time
based on the parameters passed to :meth:`_engine.Connection.execute`.
:param inline: if True, no attempt will be made to retrieve the
SQL-generated default values to be provided within the statement;
in particular,
this allows SQL expressions to be rendered 'inline' within the
statement without the need to pre-execute them beforehand; for
backends that support "returning", this turns off the "implicit
returning" feature for the statement.
If both :paramref:`_expression.insert.values` and compile-time bind
parameters are present, the compile-time bind parameters override the
information specified within :paramref:`_expression.insert.values` on a
per-key basis.
The keys within :paramref:`_expression.Insert.values` can be either
:class:`~sqlalchemy.schema.Column` objects or their string
identifiers. Each key may reference one of:
* a literal data value (i.e. string, number, etc.);
* a Column object;
* a SELECT statement.
If a ``SELECT`` statement is specified which references this
``INSERT`` statement's table, the statement will be correlated
against the ``INSERT`` statement.
.. seealso::
:ref:`tutorial_core_insert` - in the :ref:`unified_tutorial`
sqlmodel.inspect
Python Library Documentation: function inspect in module sqlalchemy.inspection
inspect(subject: 'Any', raiseerr: 'bool' = True) -> 'Any'
Produce an inspection object for the given target.
The returned value in some cases may be the
same object as the one given, such as if a
:class:`_orm.Mapper` object is passed. In other
cases, it will be an instance of the registered
inspection type for the given object, such as
if an :class:`_engine.Engine` is passed, an
:class:`_reflection.Inspector` object is returned.
:param subject: the subject to be inspected.
:param raiseerr: When ``True``, if the given subject
does not
correspond to a known SQLAlchemy inspected type,
:class:`sqlalchemy.exc.NoInspectionAvailable`
is raised. If ``False``, ``None`` is returned.
sqlmodel.intersect
Python Library Documentation: function intersect in module sqlalchemy.sql._selectable_constructors
intersect(*selects: '_SelectStatementForCompoundArgument[_TP]') -> 'CompoundSelect[_TP]'
Return an ``INTERSECT`` of multiple selectables.
The returned object is an instance of
:class:`_expression.CompoundSelect`.
:param \*selects:
a list of :class:`_expression.Select` instances.
sqlmodel.intersect_all
Python Library Documentation: function intersect_all in module sqlalchemy.sql._selectable_constructors
intersect_all(*selects: '_SelectStatementForCompoundArgument[_TP]') -> 'CompoundSelect[_TP]'
Return an ``INTERSECT ALL`` of multiple selectables.
The returned object is an instance of
:class:`_expression.CompoundSelect`.
:param \*selects:
a list of :class:`_expression.Select` instances.
sqlmodel.join
Python Library Documentation: function join in module sqlalchemy.sql._selectable_constructors
join(left: '_FromClauseArgument', right: '_FromClauseArgument', onclause: 'Optional[_OnClauseArgument]' = None, isouter: 'bool' = False, full: 'bool' = False) -> 'Join'
Produce a :class:`_expression.Join` object, given two
:class:`_expression.FromClause`
expressions.
E.g.::
j = join(
user_table, address_table, user_table.c.id == address_table.c.user_id
)
stmt = select(user_table).select_from(j)
would emit SQL along the lines of:
.. sourcecode:: sql
SELECT user.id, user.name FROM user
JOIN address ON user.id = address.user_id
Similar functionality is available given any
:class:`_expression.FromClause` object (e.g. such as a
:class:`_schema.Table`) using
the :meth:`_expression.FromClause.join` method.
:param left: The left side of the join.
:param right: the right side of the join; this is any
:class:`_expression.FromClause` object such as a
:class:`_schema.Table` object, and
may also be a selectable-compatible object such as an ORM-mapped
class.
:param onclause: a SQL expression representing the ON clause of the
join. If left at ``None``, :meth:`_expression.FromClause.join`
will attempt to
join the two tables based on a foreign key relationship.
:param isouter: if True, render a LEFT OUTER JOIN, instead of JOIN.
:param full: if True, render a FULL OUTER JOIN, instead of JOIN.
.. seealso::
:meth:`_expression.FromClause.join` - method form,
based on a given left side.
:class:`_expression.Join` - the type of object produced.
sqlmodel.lambda_stmt
Python Library Documentation: function lambda_stmt in module sqlalchemy.sql.lambdas
lambda_stmt(lmb: '_StmtLambdaType', enable_tracking: 'bool' = True, track_closure_variables: 'bool' = True, track_on: 'Optional[object]' = None, global_track_bound_values: 'bool' = True, track_bound_values: 'bool' = True, lambda_cache: 'Optional[_LambdaCacheType]' = None) -> 'StatementLambdaElement'
Produce a SQL statement that is cached as a lambda.
The Python code object within the lambda is scanned for both Python
literals that will become bound parameters as well as closure variables
that refer to Core or ORM constructs that may vary. The lambda itself
will be invoked only once per particular set of constructs detected.
E.g.::
from sqlalchemy import lambda_stmt
stmt = lambda_stmt(lambda: table.select())
stmt += lambda s: s.where(table.c.id == 5)
result = connection.execute(stmt)
The object returned is an instance of :class:`_sql.StatementLambdaElement`.
.. versionadded:: 1.4
:param lmb: a Python function, typically a lambda, which takes no arguments
and returns a SQL expression construct
:param enable_tracking: when False, all scanning of the given lambda for
changes in closure variables or bound parameters is disabled. Use for
a lambda that produces the identical results in all cases with no
parameterization.
:param track_closure_variables: when False, changes in closure variables
within the lambda will not be scanned. Use for a lambda where the
state of its closure variables will never change the SQL structure
returned by the lambda.
:param track_bound_values: when False, bound parameter tracking will
be disabled for the given lambda. Use for a lambda that either does
not produce any bound values, or where the initial bound values never
change.
:param global_track_bound_values: when False, bound parameter tracking
will be disabled for the entire statement including additional links
added via the :meth:`_sql.StatementLambdaElement.add_criteria` method.
:param lambda_cache: a dictionary or other mapping-like object where
information about the lambda's Python code as well as the tracked closure
variables in the lambda itself will be stored. Defaults
to a global LRU cache. This cache is independent of the "compiled_cache"
used by the :class:`_engine.Connection` object.
.. seealso::
:ref:`engine_lambda_caching`
sqlmodel.lateral
Python Library Documentation: function lateral in module sqlalchemy.sql._selectable_constructors
lateral(selectable: 'Union[SelectBase, _FromClauseArgument]', name: 'Optional[str]' = None) -> 'LateralFromClause'
Return a :class:`_expression.Lateral` object.
:class:`_expression.Lateral` is an :class:`_expression.Alias`
subclass that represents
a subquery with the LATERAL keyword applied to it.
The special behavior of a LATERAL subquery is that it appears in the
FROM clause of an enclosing SELECT, but may correlate to other
FROM clauses of that SELECT. It is a special case of subquery
only supported by a small number of backends, currently more recent
PostgreSQL versions.
.. seealso::
:ref:`tutorial_lateral_correlation` - overview of usage.
sqlmodel.literal
Python Library Documentation: function literal in module sqlalchemy.sql.elements
literal(value: 'Any', type_: 'Optional[_TypeEngineArgument[Any]]' = None, literal_execute: 'bool' = False) -> 'BindParameter[Any]'
Return a literal clause, bound to a bind parameter.
Literal clauses are created automatically when non-
:class:`_expression.ClauseElement` objects (such as strings, ints, dates,
etc.) are
used in a comparison operation with a :class:`_expression.ColumnElement`
subclass,
such as a :class:`~sqlalchemy.schema.Column` object. Use this function
to force the generation of a literal clause, which will be created as a
:class:`BindParameter` with a bound value.
:param value: the value to be bound. Can be any Python object supported by
the underlying DB-API, or is translatable via the given type argument.
:param type\_: an optional :class:`~sqlalchemy.types.TypeEngine` which will
provide bind-parameter translation for this literal.
:param literal_execute: optional bool, when True, the SQL engine will
attempt to render the bound value directly in the SQL statement at
execution time rather than providing as a parameter value.
.. versionadded:: 2.0
sqlmodel.literal_column
Python Library Documentation: function literal_column in module sqlalchemy.sql.elements
literal_column(text: 'str', type_: 'Optional[_TypeEngineArgument[_T]]' = None) -> 'ColumnClause[_T]'
Produce a :class:`.ColumnClause` object that has the
:paramref:`_expression.column.is_literal` flag set to True.
:func:`_expression.literal_column` is similar to
:func:`_expression.column`, except that
it is more often used as a "standalone" column expression that renders
exactly as stated; while :func:`_expression.column`
stores a string name that
will be assumed to be part of a table and may be quoted as such,
:func:`_expression.literal_column` can be that,
or any other arbitrary column-oriented
expression.
:param text: the text of the expression; can be any SQL expression.
Quoting rules will not be applied. To specify a column-name expression
which should be subject to quoting rules, use the :func:`column`
function.
:param type\_: an optional :class:`~sqlalchemy.types.TypeEngine`
object which will
provide result-set translation and additional expression semantics for
this column. If left as ``None`` the type will be :class:`.NullType`.
.. seealso::
:func:`_expression.column`
:func:`_expression.text`
:ref:`tutorial_select_arbitrary_text`
sqlmodel.main
Python Library Documentation: module sqlmodel.main in sqlmodel
NAME
sqlmodel.main
CLASSES
builtins.object
FieldInfoMetadata
pydantic._internal._model_construction.ModelMetaclass(abc.ABCMeta)
SQLModelMetaclass(pydantic._internal._model_construction.ModelMetaclass, sqlalchemy.orm.decl_api.DeclarativeMeta)
pydantic._internal._repr.Representation(builtins.object)
RelationshipInfo
pydantic.fields.FieldInfo(pydantic._internal._repr.Representation)
FieldInfo
pydantic.main.BaseModel(builtins.object)
SQLModel
sqlalchemy.orm.decl_api.DeclarativeMeta(sqlalchemy.orm.decl_api.DeclarativeAttributeIntercept)
SQLModelMetaclass(pydantic._internal._model_construction.ModelMetaclass, sqlalchemy.orm.decl_api.DeclarativeMeta)
class FieldInfo(pydantic.fields.FieldInfo)
| FieldInfo(default: 'Any' = PydanticUndefined, **kwargs: 'Any') -> 'None'
|
| Method resolution order:
| FieldInfo
| pydantic.fields.FieldInfo
| pydantic._internal._repr.Representation
| builtins.object
|
| Methods defined here:
|
| __init__(self, default: 'Any' = PydanticUndefined, **kwargs: 'Any') -> 'None'
| This class should generally not be initialized directly; instead, use the `pydantic.fields.Field` function
| or one of the constructor classmethods.
|
| See the signature of `pydantic.fields.Field` for more details about the expected arguments.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.fields.FieldInfo:
|
| __repr_args__(self) -> 'ReprArgs'
| Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden.
|
| Can either return:
| * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]`
| * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]`
|
| apply_typevars_map(self, typevars_map: 'Mapping[TypeVar, Any] | None', globalns: 'GlobalsNamespace | None' = None, localns: 'MappingNamespace | None' = None) -> 'None'
| Apply a `typevars_map` to the annotation.
|
| This method is used when analyzing parametrized generic types to replace typevars with their concrete types.
|
| This method applies the `typevars_map` to the annotation in place.
|
| Args:
| typevars_map: A dictionary mapping type variables to their concrete types.
| globalns: The globals namespace to use during type annotation evaluation.
| localns: The locals namespace to use during type annotation evaluation.
|
| See Also:
| pydantic._internal._generics.replace_types is used for replacing the typevars with
| their concrete types.
|
| asdict(self) -> '_FieldInfoAsDict'
| Return a dictionary representation of the `FieldInfo` instance.
|
| The returned value is a dictionary with three items:
|
| * `annotation`: The type annotation of the field.
| * `metadata`: The metadata list.
| * `attributes`: A mapping of the remaining `FieldInfo` attributes to their values (e.g. `alias`, `title`).
|
| get_default(self, *, call_default_factory: 'bool' = False, validated_data: 'dict[str, Any] | None' = None) -> 'Any'
| Get the default value.
|
| We expose an option for whether to call the default_factory (if present), as calling it may
| result in side effects that we want to avoid. However, there are times when it really should
| be called (namely, when instantiating a model via `model_construct`).
|
| Args:
| call_default_factory: Whether to call the default factory or not.
| validated_data: The already validated data to be passed to the default factory.
|
| Returns:
| The default value, calling the default factory if requested or `PydanticUndefined` if not set.
|
| is_required(self) -> 'bool'
| Check if the field is required (i.e., does not have a default value or factory).
|
| Returns:
| `True` if the field is required, `False` otherwise.
|
| rebuild_annotation(self) -> 'Any'
| Attempts to rebuild the original annotation for use in function signatures.
|
| If metadata is present, it adds it to the original annotation using
| `Annotated`. Otherwise, it returns the original annotation as-is.
|
| Note that because the metadata has been flattened, the original annotation
| may not be reconstructed exactly as originally provided, e.g. if the original
| type had unrecognized annotations, or was annotated with a call to `pydantic.Field`.
|
| Returns:
| The rebuilt annotation.
|
| ----------------------------------------------------------------------
| Static methods inherited from pydantic.fields.FieldInfo:
|
| from_annotated_attribute(annotation: 'type[Any]', default: 'Any', *, _source: 'AnnotationSource' = <AnnotationSource.ANY: 7>) -> 'FieldInfo'
| Create `FieldInfo` from an annotation with a default value.
|
| This is used in cases like the following:
|
| ```python
| from typing import Annotated
|
| import annotated_types
|
| import pydantic
|
| class MyModel(pydantic.BaseModel):
| foo: int = 4 # <-- like this
| bar: Annotated[int, annotated_types.Gt(4)] = 4 # <-- or this
| spam: Annotated[int, pydantic.Field(gt=4)] = 4 # <-- or this
| ```
|
| Args:
| annotation: The type annotation of the field.
| default: The default value of the field.
|
| Returns:
| A field object with the passed values.
|
| from_annotation(annotation: 'type[Any]', *, _source: 'AnnotationSource' = <AnnotationSource.ANY: 7>) -> 'FieldInfo'
| Creates a `FieldInfo` instance from a bare annotation.
|
| This function is used internally to create a `FieldInfo` from a bare annotation like this:
|
| ```python
| import pydantic
|
| class MyModel(pydantic.BaseModel):
| foo: int # <-- like this
| ```
|
| We also account for the case where the annotation can be an instance of `Annotated` and where
| one of the (not first) arguments in `Annotated` is an instance of `FieldInfo`, e.g.:
|
| ```python
| from typing import Annotated
|
| import annotated_types
|
| import pydantic
|
| class MyModel(pydantic.BaseModel):
| foo: Annotated[int, annotated_types.Gt(42)]
| bar: Annotated[int, pydantic.Field(gt=42)]
| ```
|
| Args:
| annotation: An annotation object.
|
| Returns:
| An instance of the field metadata.
|
| from_field(default: 'Any' = PydanticUndefined, **kwargs: 'Unpack[_FromFieldInfoInputs]') -> 'FieldInfo'
| Create a new `FieldInfo` object with the `Field` function.
|
| Args:
| default: The default value for the field. Defaults to Undefined.
| **kwargs: Additional arguments dictionary.
|
| Raises:
| TypeError: If 'annotation' is passed as a keyword argument.
|
| Returns:
| A new FieldInfo object with the given parameters.
|
| Example:
| This is how you can create a field with default value like this:
|
| ```python
| import pydantic
|
| class MyModel(pydantic.BaseModel):
| foo: int = pydantic.Field(4)
| ```
|
| merge_field_infos(*field_infos: 'FieldInfo', **overrides: 'Any') -> 'FieldInfo'
| Merge `FieldInfo` instances keeping only explicitly set attributes.
|
| Later `FieldInfo` instances override earlier ones.
|
| Returns:
| FieldInfo: A merged FieldInfo instance.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.fields.FieldInfo:
|
| default_factory_takes_validated_data
| Whether the provided default factory callable has a validated data parameter.
|
| Returns `None` if no default factory is set.
|
| deprecation_message
| The deprecation message to be emitted, or `None` if not set.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.fields.FieldInfo:
|
| alias
|
| alias_priority
|
| annotation
|
| default
|
| default_factory
|
| deprecated
|
| description
|
| discriminator
|
| examples
|
| exclude
|
| exclude_if
|
| field_title_generator
|
| frozen
|
| init
|
| init_var
|
| json_schema_extra
|
| kw_only
|
| metadata
|
| repr
|
| serialization_alias
|
| title
|
| validate_default
|
| validation_alias
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.fields.FieldInfo:
|
| __final__ = True
|
| metadata_lookup = {'allow_inf_nan': None, 'coerce_numbers_to_str': Non...
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic._internal._repr.Representation:
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]'
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_name__(self) -> 'str'
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str'
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str'
|
| __rich_repr__(self) -> 'RichReprResult'
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __str__(self) -> 'str'
| Return str(self).
class FieldInfoMetadata(builtins.object)
| FieldInfoMetadata(primary_key: 'bool | UndefinedType' = PydanticUndefined, nullable: 'bool | UndefinedType' = PydanticUndefined, foreign_key: 'Any' = PydanticUndefined, ondelete: 'OnDeleteType | UndefinedType' = PydanticUndefined, unique: 'bool | UndefinedType' = PydanticUndefined, index: 'bool | UndefinedType' = PydanticUndefined, sa_type: 'type[Any] | UndefinedType' = PydanticUndefined, sa_column: 'Column[Any] | UndefinedType' = PydanticUndefined, sa_column_args: 'Sequence[Any] | UndefinedType' = PydanticUndefined, sa_column_kwargs: 'Mapping[str, Any] | UndefinedType' = PydanticUndefined) -> None
|
| FieldInfoMetadata(primary_key: 'bool | UndefinedType' = PydanticUndefined, nullable: 'bool | UndefinedType' = PydanticUndefined, foreign_key: 'Any' = PydanticUndefined, ondelete: 'OnDeleteType | UndefinedType' = PydanticUndefined, unique: 'bool | UndefinedType' = PydanticUndefined, index: 'bool | UndefinedType' = PydanticUndefined, sa_type: 'type[Any] | UndefinedType' = PydanticUndefined, sa_column: 'Column[Any] | UndefinedType' = PydanticUndefined, sa_column_args: 'Sequence[Any] | UndefinedType' = PydanticUndefined, sa_column_kwargs: 'Mapping[str, Any] | UndefinedType' = PydanticUndefined)
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __init__(self, primary_key: 'bool | UndefinedType' = PydanticUndefined, nullable: 'bool | UndefinedType' = PydanticUndefined, foreign_key: 'Any' = PydanticUndefined, ondelete: 'OnDeleteType | UndefinedType' = PydanticUndefined, unique: 'bool | UndefinedType' = PydanticUndefined, index: 'bool | UndefinedType' = PydanticUndefined, sa_type: 'type[Any] | UndefinedType' = PydanticUndefined, sa_column: 'Column[Any] | UndefinedType' = PydanticUndefined, sa_column_args: 'Sequence[Any] | UndefinedType' = PydanticUndefined, sa_column_kwargs: 'Mapping[str, Any] | UndefinedType' = PydanticUndefined) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'foreign_key': 'Any', 'index': 'bool | UndefinedTyp...
|
| __dataclass_fields__ = {'foreign_key': Field(name='foreign_key',type='...
|
| __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
|
| __hash__ = None
|
| __match_args__ = ('primary_key', 'nullable', 'foreign_key', 'ondelete'...
|
| foreign_key = PydanticUndefined
|
| index = PydanticUndefined
|
| nullable = PydanticUndefined
|
| ondelete = PydanticUndefined
|
| primary_key = PydanticUndefined
|
| sa_column = PydanticUndefined
|
| sa_column_args = PydanticUndefined
|
| sa_column_kwargs = PydanticUndefined
|
| sa_type = PydanticUndefined
|
| unique = PydanticUndefined
class RelationshipInfo(pydantic._internal._repr.Representation)
| RelationshipInfo(*, back_populates: 'str | None' = None, cascade_delete: 'bool | None' = False, passive_deletes: "bool | Literal['all'] | None" = False, link_model: 'Any | None' = None, sa_relationship: 'RelationshipProperty | None' = None, sa_relationship_args: 'Sequence[Any] | None' = None, sa_relationship_kwargs: 'Mapping[str, Any] | None' = None) -> 'None'
|
| Method resolution order:
| RelationshipInfo
| pydantic._internal._repr.Representation
| builtins.object
|
| Methods defined here:
|
| __init__(self, *, back_populates: 'str | None' = None, cascade_delete: 'bool | None' = False, passive_deletes: "bool | Literal['all'] | None" = False, link_model: 'Any | None' = None, sa_relationship: 'RelationshipProperty | None' = None, sa_relationship_args: 'Sequence[Any] | None' = None, sa_relationship_kwargs: 'Mapping[str, Any] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic._internal._repr.Representation:
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]'
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> 'ReprArgs'
| Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden.
|
| Can either return:
| * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]`
| * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]`
|
| __repr_name__(self) -> 'str'
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str'
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str'
|
| __rich_repr__(self) -> 'RichReprResult'
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __str__(self) -> 'str'
| Return str(self).
class SQLModel(pydantic.main.BaseModel)
| SQLModel() -> None
|
| Method resolution order:
| SQLModel
| pydantic.main.BaseModel
| builtins.object
|
| Methods defined here:
|
| __init__(__pydantic_self__, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __repr_args__(self) -> 'Sequence[tuple[str | None, Any]]'
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'builtins.dict[str, Any]'
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'builtins.dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
|
| Args:
| mode: The mode in which `to_python` should run.
| If mode is 'json', the output will only contain JSON serializable types.
| If mode is 'python', the output may contain non-JSON-serializable Python objects.
| include: A set of fields to include in the output.
| exclude: A set of fields to exclude from the output.
| context: Additional context to pass to the serializer.
| by_alias: Whether to use the field's alias in the dictionary key if defined.
| exclude_unset: Whether to exclude fields that have not been explicitly set.
| exclude_defaults: Whether to exclude fields that are set to their default value.
| exclude_none: Whether to exclude fields that have a value of `None`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
| warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
| "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| sqlmodel_update(self: '_TSQLModel', obj: 'builtins.dict[str, Any] | BaseModel', *, update: 'builtins.dict[str, Any] | None' = None) -> '_TSQLModel'
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_orm(obj: 'Any', update: 'builtins.dict[str, Any] | None' = None) -> '_TSQLModel'
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, from_attributes: 'bool | None' = None, context: 'builtins.dict[str, Any] | None' = None, update: 'builtins.dict[str, Any] | None' = None) -> '_TSQLModel'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| parse_obj(obj: 'Any', update: 'builtins.dict[str, Any] | None' = None) -> '_TSQLModel'
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, *args: 'Any', **kwargs: 'Any')
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstract__ = True
|
| __abstractmethods__ = frozenset()
|
| __allow_unmapped__ = True
|
| __annotations__ = {'__name__': 'ClassVar[str]', '__sqlmodel_relationsh...
|
| __class_vars__ = {'__name__', '__sqlmodel_relationships__', '__tablena...
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'sqlmodel.main.SQLModel'>, '...
|
| __pydantic_custom_init__ = True
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {}
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = {'__class__': <pydantic._internal._mod...
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="SQLModel", validator=M...
|
| __signature__ = <Signature () -> None>
|
| __sqlmodel_relationships__ = {}
|
| __tablename__ = 'sqlmodel'
|
| __weakref__ = None
|
| metadata = MetaData()
|
| model_config = {'from_attributes': True, 'registry': PydanticUndefined...
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| Args:
| include: Optional set or mapping specifying which fields to include in the copied model.
| exclude: Optional set or mapping specifying which fields to exclude in the copied model.
| update: Optional dictionary of field-value pairs to override field values in the copied model.
| deep: If True, the values of fields that are Pydantic models will be deep-copied.
|
| Returns:
| A copy of the model with included, excluded and updated fields as specified.
|
| json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| Args:
| update: Values to change/add in the new model. Note: the data is not validated
| before creating the new model. You should trust this data.
| deep: Set to `True` to make a deep copy of the model.
|
| Returns:
| New model instance.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| Generates a JSON representation of the model using Pydantic's `to_json` method.
|
| Args:
| indent: Indentation to use in the JSON output. If None is passed, the output will be compact.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| include: Field(s) to include in the JSON output.
| exclude: Field(s) to exclude from the JSON output.
| context: Additional context to pass to the serializer.
| by_alias: Whether to serialize using field aliases.
| exclude_unset: Whether to exclude fields that have not been explicitly set.
| exclude_defaults: Whether to exclude fields that are set to their default value.
| exclude_none: Whether to exclude fields that have a value of `None`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
| warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
| "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| Creates a new instance of the `Model` class with validated data.
|
| Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
| Default values are respected, but no other validation is performed.
|
| !!! note
| `model_construct()` generally respects the `model_config.extra` setting on the provided model.
| That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
| and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
| Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
| an error if extra values are passed, but they will be ignored.
|
| Args:
| _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
| this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
| Otherwise, the field names from the `values` argument will be used.
| values: Trusted or pre-validated data dictionary.
|
| Returns:
| A new instance of the `Model` class with validated data.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| schema_generator: To override the logic used to generate the JSON schema, as a subclass of
| `GenerateJsonSchema` with your desired modifications
| mode: The mode in which to generate the schema.
|
| Returns:
| The JSON schema for the given model class.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate the given object with string data against the Pydantic model.
|
| Args:
| obj: The object containing string data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {}
class SQLModelMetaclass(pydantic._internal._model_construction.ModelMetaclass, sqlalchemy.orm.decl_api.DeclarativeMeta)
| SQLModelMetaclass(name: 'str', bases: 'tuple[type[Any], ...]', class_dict: 'dict[str, Any]', **kwargs: 'Any') -> 'Any'
|
| Method resolution order:
| SQLModelMetaclass
| pydantic._internal._model_construction.ModelMetaclass
| abc.ABCMeta
| sqlalchemy.orm.decl_api.DeclarativeMeta
| sqlalchemy.orm.decl_api.DeclarativeAttributeIntercept
| sqlalchemy.orm.decl_api._DynamicAttributesType
| builtins.type
| sqlalchemy.inspection.Inspectable
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __delattr__(cls, name: 'str') -> 'None'
| Implement delattr(self, name).
|
| __init__(cls, classname: 'str', bases: 'tuple[type, ...]', dict_: 'dict[str, Any]', **kw: 'Any') -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __setattr__(cls, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, name: 'str', bases: 'tuple[type[Any], ...]', class_dict: 'dict[str, Any]', **kwargs: 'Any') -> 'Any'
| Metaclass for creating Pydantic models.
|
| Args:
| cls_name: The name of the class to be created.
| bases: The base classes of the class to be created.
| namespace: The attribute dictionary of the class to be created.
| __pydantic_generic_metadata__: Metadata for generic models.
| __pydantic_reset_parent_namespace__: Reset parent namespace.
| _create_model_module: The module of the class to be created, if created by `create_model`.
| **kwargs: Catch-all for any other keyword arguments.
|
| Returns:
| The new class created by the metaclass.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'__sqlmodel_relationships__': 'dict[str, Relationsh...
|
| __parameters__ = ()
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic._internal._model_construction.ModelMetaclass:
|
| __dir__(self) -> 'list[str]'
| Specialized __dir__ implementation for types.
|
| __getattr__(self, item: 'str') -> 'Any'
| This is necessary to keep attribute access working for class attribute access.
|
| __instancecheck__(self, instance, /) from builtins.type
| Check if an object is an instance.
|
| __subclasscheck__(self, subclass, /) from builtins.type
| Check if a class is a subclass.
|
| register(self, subclass: 'type[_T]') -> 'type[_T]'
| Register a virtual subclass of an ABC.
|
| Returns the subclass, to allow usage as a class decorator.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic._internal._model_construction.ModelMetaclass:
|
| __prepare__(*args: 'Any', **kwargs: 'Any') -> 'dict[str, object]'
| __prepare__() -> dict
| used to create the namespace for the class statement
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic._internal._model_construction.ModelMetaclass:
|
| __fields__
|
| __pydantic_fields_complete__
| Whether the fields were successfully collected (i.e. type hints were successfully resolved).
|
| This is a private attribute, not meant to be used outside Pydantic.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic._internal._model_construction.ModelMetaclass:
|
| __dataclass_transform__ = {'eq_default': True, 'field_specifiers': (<o...
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from sqlalchemy.orm.decl_api.DeclarativeAttributeIntercept:
|
| __orig_bases__ = (<class 'sqlalchemy.orm.decl_api._DynamicAttributesTy...
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.type:
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __or__(self, value, /)
| Return self|value.
|
| __repr__(self, /)
| Return repr(self).
|
| __ror__(self, value, /)
| Return value|self.
|
| __sizeof__(self, /)
| Return memory consumption of the type object.
|
| __subclasses__(self, /)
| Return a list of immediate subclasses.
|
| mro(self, /)
| Return a type's method resolution order.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.type:
|
| __abstractmethods__
|
| __dict__
|
| __text_signature__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from builtins.type:
|
| __base__ = <class 'pydantic._internal._model_construction.ModelMetacla...
|
| __bases__ = (<class 'pydantic._internal._model_construction.ModelMetac...
|
| __basicsize__ = 920
|
| __dictoffset__ = 264
|
| __flags__ = 2156420608
|
| __itemsize__ = 40
|
| __mro__ = (<class 'sqlmodel.main.SQLModelMetaclass'>, <class 'pydantic...
|
| __type_params__ = ()
|
| __weakrefoffset__ = 368
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __class_getitem__(...)
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
|
| __init_subclass__(...)
| Function to initialize subclasses.
FUNCTIONS
Field(default: 'Any' = PydanticUndefined, *, default_factory: 'NoArgAnyCallable | None' = None, alias: 'str | None' = None, validation_alias: 'str | None' = None, serialization_alias: 'str | None' = None, title: 'str | None' = None, description: 'str | None' = None, exclude: 'Set[int | str] | Mapping[int | str, Any] | Any' = None, include: 'Set[int | str] | Mapping[int | str, Any] | Any' = None, const: 'bool | None' = None, gt: 'float | None' = None, ge: 'float | None' = None, lt: 'float | None' = None, le: 'float | None' = None, multiple_of: 'float | None' = None, max_digits: 'int | None' = None, decimal_places: 'int | None' = None, min_items: 'int | None' = None, max_items: 'int | None' = None, unique_items: 'bool | None' = None, min_length: 'int | None' = None, max_length: 'int | None' = None, allow_mutation: 'bool' = True, regex: 'str | None' = None, discriminator: 'str | None' = None, repr: 'bool' = True, primary_key: 'bool | UndefinedType' = PydanticUndefined, foreign_key: 'Any' = PydanticUndefined, ondelete: 'OnDeleteType | UndefinedType' = PydanticUndefined, unique: 'bool | UndefinedType' = PydanticUndefined, nullable: 'bool | UndefinedType' = PydanticUndefined, index: 'bool | UndefinedType' = PydanticUndefined, sa_type: 'type[Any] | UndefinedType' = PydanticUndefined, sa_column: 'Column | UndefinedType' = PydanticUndefined, sa_column_args: 'Sequence[Any] | UndefinedType' = PydanticUndefined, sa_column_kwargs: 'Mapping[str, Any] | UndefinedType' = PydanticUndefined, schema_extra: 'dict[str, Any] | None' = None) -> 'Any'
Relationship(*, back_populates: 'str | None' = None, cascade_delete: 'bool | None' = False, passive_deletes: "bool | Literal['all'] | None" = False, link_model: 'Any | None' = None, sa_relationship: 'RelationshipProperty[Any] | None' = None, sa_relationship_args: 'Sequence[Any] | None' = None, sa_relationship_kwargs: 'Mapping[str, Any] | None' = None) -> 'Any'
__dataclass_transform__(*, eq_default: 'bool' = True, order_default: 'bool' = False, kw_only_default: 'bool' = False, field_descriptors: 'tuple[type | Callable[..., Any], ...]' = ()) -> 'Callable[[_T], _T]'
get_column_from_field(field: 'Any') -> 'Column'
get_sqlalchemy_type(field: 'Any') -> 'Any'
DATA
ClassVar = typing.ClassVar
Special type construct to mark class variables.
An annotation wrapped in ClassVar indicates that a given
attribute is intended to be used as a class variable and
should not be set on instances of that class.
Usage::
class Starship:
stats: ClassVar[dict[str, int]] = {} # class variable
damage: int = 10 # instance variable
ClassVar accepts only types and cannot be further subscribed.
Note that ClassVar is not a class itself, and should not
be used with isinstance() or issubclass().
IncEx = set[int] | set[str] | collections.abc.Mapping[in...ing[str, ty...
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
NoArgAnyCallable = collections.abc.Callable[[], typing.Any]
OnDeleteType = typing.Literal['CASCADE', 'SET NULL', 'RESTRICT']
PYDANTIC_MINOR_VERSION = (2, 13)
TYPE_CHECKING = False
TypeAlias = typing.TypeAlias
Special form for marking type aliases.
Use TypeAlias to indicate that an assignment should
be recognized as a proper type alias definition by type
checkers.
For example::
Predicate: TypeAlias = Callable[..., bool]
It's invalid when used anywhere except as in the example above.
Undefined = PydanticUndefined
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
__annotations__ = {'IncEx': 'TypeAlias'}
default_registry = <sqlalchemy.orm.decl_api.registry object>
finish_init = <ContextVar name='finish_init' default=True>
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\sqlmodel\main.py
sqlmodel.modifier
Python Library Documentation: _FunctionGenerator in module sqlalchemy.sql.functions object
class _FunctionGenerator(builtins.object)
| _FunctionGenerator(**opts: 'Any') -> 'None'
|
| Generate SQL function expressions.
|
| :data:`.func` is a special object instance which generates SQL
| functions based on name-based attributes, e.g.:
|
| .. sourcecode:: pycon+sql
|
| >>> print(func.count(1))
| {printsql}count(:param_1)
|
| The returned object is an instance of :class:`.Function`, and is a
| column-oriented SQL element like any other, and is used in that way:
|
| .. sourcecode:: pycon+sql
|
| >>> print(select(func.count(table.c.id)))
| {printsql}SELECT count(sometable.id) FROM sometable
|
| Any name can be given to :data:`.func`. If the function name is unknown to
| SQLAlchemy, it will be rendered exactly as is. For common SQL functions
| which SQLAlchemy is aware of, the name may be interpreted as a *generic
| function* which will be compiled appropriately to the target database:
|
| .. sourcecode:: pycon+sql
|
| >>> print(func.current_timestamp())
| {printsql}CURRENT_TIMESTAMP
|
| To call functions which are present in dot-separated packages,
| specify them in the same manner:
|
| .. sourcecode:: pycon+sql
|
| >>> print(func.stats.yield_curve(5, 10))
| {printsql}stats.yield_curve(:yield_curve_1, :yield_curve_2)
|
| SQLAlchemy can be made aware of the return type of functions to enable
| type-specific lexical and result-based behavior. For example, to ensure
| that a string-based function returns a Unicode value and is similarly
| treated as a string in expressions, specify
| :class:`~sqlalchemy.types.Unicode` as the type:
|
| .. sourcecode:: pycon+sql
|
| >>> print(
| ... func.my_string("hi", type_=Unicode)
| ... + " "
| ... + func.my_string("there", type_=Unicode)
| ... )
| {printsql}my_string(:my_string_1) || :my_string_2 || my_string(:my_string_3)
|
| The object returned by a :data:`.func` call is usually an instance of
| :class:`.Function`.
| This object meets the "column" interface, including comparison and labeling
| functions. The object can also be passed the :meth:`~.Connectable.execute`
| method of a :class:`_engine.Connection` or :class:`_engine.Engine`,
| where it will be
| wrapped inside of a SELECT statement first::
|
| print(connection.execute(func.current_timestamp()).scalar())
|
| In a few exception cases, the :data:`.func` accessor
| will redirect a name to a built-in expression such as :func:`.cast`
| or :func:`.extract`, as these names have well-known meaning
| but are not exactly the same as "functions" from a SQLAlchemy
| perspective.
|
| Functions which are interpreted as "generic" functions know how to
| calculate their return type automatically. For a listing of known generic
| functions, see :ref:`generic_functions`.
|
| .. note::
|
| The :data:`.func` construct has only limited support for calling
| standalone "stored procedures", especially those with special
| parameterization concerns.
|
| See the section :ref:`stored_procedures` for details on how to use
| the DBAPI-level ``callproc()`` method for fully traditional stored
| procedures.
|
| .. seealso::
|
| :ref:`tutorial_functions` - in the :ref:`unified_tutorial`
|
| :class:`.Function`
|
| Methods defined here:
|
| __call__(self, *c: 'Any', **kwargs: 'Any') -> 'Function[Any]'
| Call self as a function.
|
| __getattr__(self, name: 'str') -> '_FunctionGenerator'
|
| __init__(self, **opts: 'Any') -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
sqlmodel.not_
Python Library Documentation: function not_ in module sqlmodel.sql.expression
not_(clause: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[~_T], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[~_T], sqlalchemy.sql.roles.TypedColumnsClauseRole[~_T], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), ~_T]) -> sqlalchemy.sql.elements.ColumnElement[~_T]
sqlmodel.null
Python Library Documentation: function null in module sqlalchemy.sql._elements_constructors
null() -> 'Null'
Return a constant :class:`.Null` construct.
sqlmodel.nulls_first
Python Library Documentation: function nulls_first in module sqlmodel.sql.expression
nulls_first(column: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[~_T], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[~_T], sqlalchemy.sql.roles.TypedColumnsClauseRole[~_T], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), ~_T]) -> sqlalchemy.sql.elements.UnaryExpression[~_T]
sqlmodel.nulls_last
Python Library Documentation: function nulls_last in module sqlmodel.sql.expression
nulls_last(column: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[~_T], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[~_T], sqlalchemy.sql.roles.TypedColumnsClauseRole[~_T], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), ~_T]) -> sqlalchemy.sql.elements.UnaryExpression[~_T]
sqlmodel.nullsfirst
Python Library Documentation: function nulls_first in module sqlalchemy.sql._elements_constructors
nulls_first(column: '_ColumnExpressionArgument[_T]') -> 'UnaryExpression[_T]'
Produce the ``NULLS FIRST`` modifier for an ``ORDER BY`` expression.
:func:`.nulls_first` is intended to modify the expression produced
by :func:`.asc` or :func:`.desc`, and indicates how NULL values
should be handled when they are encountered during ordering::
from sqlalchemy import desc, nulls_first
stmt = select(users_table).order_by(nulls_first(desc(users_table.c.name)))
The SQL expression from the above would resemble:
.. sourcecode:: sql
SELECT id, name FROM user ORDER BY name DESC NULLS FIRST
Like :func:`.asc` and :func:`.desc`, :func:`.nulls_first` is typically
invoked from the column expression itself using
:meth:`_expression.ColumnElement.nulls_first`,
rather than as its standalone
function version, as in::
stmt = select(users_table).order_by(
users_table.c.name.desc().nulls_first()
)
.. versionchanged:: 1.4 :func:`.nulls_first` is renamed from
:func:`.nullsfirst` in previous releases.
The previous name remains available for backwards compatibility.
.. seealso::
:func:`.asc`
:func:`.desc`
:func:`.nulls_last`
:meth:`_expression.Select.order_by`
sqlmodel.nullslast
Python Library Documentation: function nulls_last in module sqlalchemy.sql._elements_constructors
nulls_last(column: '_ColumnExpressionArgument[_T]') -> 'UnaryExpression[_T]'
Produce the ``NULLS LAST`` modifier for an ``ORDER BY`` expression.
:func:`.nulls_last` is intended to modify the expression produced
by :func:`.asc` or :func:`.desc`, and indicates how NULL values
should be handled when they are encountered during ordering::
from sqlalchemy import desc, nulls_last
stmt = select(users_table).order_by(nulls_last(desc(users_table.c.name)))
The SQL expression from the above would resemble:
.. sourcecode:: sql
SELECT id, name FROM user ORDER BY name DESC NULLS LAST
Like :func:`.asc` and :func:`.desc`, :func:`.nulls_last` is typically
invoked from the column expression itself using
:meth:`_expression.ColumnElement.nulls_last`,
rather than as its standalone
function version, as in::
stmt = select(users_table).order_by(users_table.c.name.desc().nulls_last())
.. versionchanged:: 1.4 :func:`.nulls_last` is renamed from
:func:`.nullslast` in previous releases.
The previous name remains available for backwards compatibility.
.. seealso::
:func:`.asc`
:func:`.desc`
:func:`.nulls_first`
:meth:`_expression.Select.order_by`
sqlmodel.or_
Python Library Documentation: function or_ in module sqlmodel.sql.expression
or_(initial_clause: Union[Literal[False], ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[bool], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[bool], sqlalchemy.sql.roles.TypedColumnsClauseRole[bool], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), bool], *clauses: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[bool], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[bool], sqlalchemy.sql.roles.TypedColumnsClauseRole[bool], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), bool]) -> sqlalchemy.sql.elements.ColumnElement[bool]
sqlmodel.orm
Python Library Documentation: package sqlmodel.orm in sqlmodel
NAME
sqlmodel.orm
PACKAGE CONTENTS
session
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\sqlmodel\orm\__init__.py
sqlmodel.outerjoin
Python Library Documentation: function outerjoin in module sqlalchemy.sql._selectable_constructors
outerjoin(left: '_FromClauseArgument', right: '_FromClauseArgument', onclause: 'Optional[_OnClauseArgument]' = None, full: 'bool' = False) -> 'Join'
Return an ``OUTER JOIN`` clause element.
The returned object is an instance of :class:`_expression.Join`.
Similar functionality is also available via the
:meth:`_expression.FromClause.outerjoin` method on any
:class:`_expression.FromClause`.
:param left: The left side of the join.
:param right: The right side of the join.
:param onclause: Optional criterion for the ``ON`` clause, is
derived from foreign key relationships established between
left and right otherwise.
To chain joins together, use the :meth:`_expression.FromClause.join`
or
:meth:`_expression.FromClause.outerjoin` methods on the resulting
:class:`_expression.Join` object.
sqlmodel.outparam
Python Library Documentation: function outparam in module sqlalchemy.sql._elements_constructors
outparam(key: 'str', type_: 'Optional[TypeEngine[_T]]' = None) -> 'BindParameter[_T]'
Create an 'OUT' parameter for usage in functions (stored procedures),
for databases which support them.
The ``outparam`` can be used like a regular function parameter.
The "output" value will be available from the
:class:`~sqlalchemy.engine.CursorResult` object via its ``out_parameters``
attribute, which returns a dictionary containing the values.
sqlmodel.over
Python Library Documentation: function over in module sqlmodel.sql.expression
over(element: sqlalchemy.sql.functions.FunctionElement[~_T], partition_by: Union[collections.abc.Iterable[Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[Any], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[Any], sqlalchemy.sql.roles.TypedColumnsClauseRole[Any], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), Any]], ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[Any], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[Any], sqlalchemy.sql.roles.TypedColumnsClauseRole[Any], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), Any, NoneType] = None, order_by: Union[collections.abc.Iterable[Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[Any], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[Any], sqlalchemy.sql.roles.TypedColumnsClauseRole[Any], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), Any]], ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[Any], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[Any], sqlalchemy.sql.roles.TypedColumnsClauseRole[Any], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), Any, NoneType] = None, range_: tuple[int | None, int | None] | None = None, rows: tuple[int | None, int | None] | None = None) -> sqlalchemy.sql.elements.Over[~_T]
sqlmodel.select
Python Library Documentation: function select in module sqlmodel.sql._expression_select_gen select(*entities: Any) -> sqlmodel.sql._expression_select_cls.Select | sqlmodel.sql._expression_select_cls.SelectOfScalar
sqlmodel.sql
Python Library Documentation: package sqlmodel.sql in sqlmodel
NAME
sqlmodel.sql
PACKAGE CONTENTS
_expression_select_cls
_expression_select_gen
base
expression
sqltypes
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\sqlmodel\sql\__init__.py
sqlmodel.table
Python Library Documentation: function table in module sqlalchemy.sql._selectable_constructors
table(name: 'str', *columns: 'ColumnClause[Any]', **kw: 'Any') -> 'TableClause'
Produce a new :class:`_expression.TableClause`.
The object returned is an instance of
:class:`_expression.TableClause`, which
represents the "syntactical" portion of the schema-level
:class:`_schema.Table` object.
It may be used to construct lightweight table constructs.
:param name: Name of the table.
:param columns: A collection of :func:`_expression.column` constructs.
:param schema: The schema name for this table.
.. versionadded:: 1.3.18 :func:`_expression.table` can now
accept a ``schema`` argument.
sqlmodel.tablesample
Python Library Documentation: function tablesample in module sqlalchemy.sql._selectable_constructors
tablesample(selectable: '_FromClauseArgument', sampling: 'Union[float, Function[Any]]', name: 'Optional[str]' = None, seed: 'Optional[roles.ExpressionElementRole[Any]]' = None) -> 'TableSample'
Return a :class:`_expression.TableSample` object.
:class:`_expression.TableSample` is an :class:`_expression.Alias`
subclass that represents
a table with the TABLESAMPLE clause applied to it.
:func:`_expression.tablesample`
is also available from the :class:`_expression.FromClause`
class via the
:meth:`_expression.FromClause.tablesample` method.
The TABLESAMPLE clause allows selecting a randomly selected approximate
percentage of rows from a table. It supports multiple sampling methods,
most commonly BERNOULLI and SYSTEM.
e.g.::
from sqlalchemy import func
selectable = people.tablesample(
func.bernoulli(1), name="alias", seed=func.random()
)
stmt = select(selectable.c.people_id)
Assuming ``people`` with a column ``people_id``, the above
statement would render as:
.. sourcecode:: sql
SELECT alias.people_id FROM
people AS alias TABLESAMPLE bernoulli(:bernoulli_1)
REPEATABLE (random())
:param sampling: a ``float`` percentage between 0 and 100 or
:class:`_functions.Function`.
:param name: optional alias name
:param seed: any real-valued SQL expression. When specified, the
REPEATABLE sub-clause is also rendered.
sqlmodel.text
Python Library Documentation: function text in module sqlalchemy.sql._elements_constructors
text(text: 'str') -> 'TextClause'
Construct a new :class:`_expression.TextClause` clause,
representing
a textual SQL string directly.
E.g.::
from sqlalchemy import text
t = text("SELECT * FROM users")
result = connection.execute(t)
The advantages :func:`_expression.text`
provides over a plain string are
backend-neutral support for bind parameters, per-statement
execution options, as well as
bind parameter and result-column typing behavior, allowing
SQLAlchemy type constructs to play a role when executing
a statement that is specified literally. The construct can also
be provided with a ``.c`` collection of column elements, allowing
it to be embedded in other SQL expression constructs as a subquery.
Bind parameters are specified by name, using the format ``:name``.
E.g.::
t = text("SELECT * FROM users WHERE id=:user_id")
result = connection.execute(t, {"user_id": 12})
For SQL statements where a colon is required verbatim, as within
an inline string, use a backslash to escape::
t = text(r"SELECT * FROM users WHERE name='\:username'")
The :class:`_expression.TextClause`
construct includes methods which can
provide information about the bound parameters as well as the column
values which would be returned from the textual statement, assuming
it's an executable SELECT type of statement. The
:meth:`_expression.TextClause.bindparams`
method is used to provide bound
parameter detail, and :meth:`_expression.TextClause.columns`
method allows
specification of return columns including names and types::
t = (
text("SELECT * FROM users WHERE id=:user_id")
.bindparams(user_id=7)
.columns(id=Integer, name=String)
)
for id, name in connection.execute(t):
print(id, name)
The :func:`_expression.text` construct is used in cases when
a literal string SQL fragment is specified as part of a larger query,
such as for the WHERE clause of a SELECT statement::
s = select(users.c.id, users.c.name).where(text("id=:user_id"))
result = connection.execute(s, {"user_id": 12})
:func:`_expression.text` is also used for the construction
of a full, standalone statement using plain text.
As such, SQLAlchemy refers
to it as an :class:`.Executable` object and may be used
like any other statement passed to an ``.execute()`` method.
:param text:
the text of the SQL statement to be created. Use ``:<param>``
to specify bind parameters; they will be compiled to their
engine-specific format.
.. warning:: The :paramref:`.text.text` argument to :func:`.text` can be passed as a Python string argument, which will be treated as **trusted SQL text** and rendered as given. **DO NOT PASS UNTRUSTED INPUT TO THIS PARAMETER**.
.. seealso::
:ref:`tutorial_select_arbitrary_text`
sqlmodel.true
Python Library Documentation: function true in module sqlalchemy.sql._elements_constructors
true() -> 'True_'
Return a constant :class:`.True_` construct.
E.g.:
.. sourcecode:: pycon+sql
>>> from sqlalchemy import true
>>> print(select(t.c.x).where(true()))
{printsql}SELECT x FROM t WHERE true
A backend which does not support true/false constants will render as
an expression against 1 or 0:
.. sourcecode:: pycon+sql
>>> print(select(t.c.x).where(true()))
{printsql}SELECT x FROM t WHERE 1 = 1
The :func:`.true` and :func:`.false` constants also feature
"short circuit" operation within an :func:`.and_` or :func:`.or_`
conjunction:
.. sourcecode:: pycon+sql
>>> print(select(t.c.x).where(or_(t.c.x > 5, true())))
{printsql}SELECT x FROM t WHERE true{stop}
>>> print(select(t.c.x).where(and_(t.c.x > 5, false())))
{printsql}SELECT x FROM t WHERE false{stop}
.. seealso::
:func:`.false`
sqlmodel.tuple_
Python Library Documentation: function tuple_ in module sqlmodel.sql.expression
tuple_(*clauses: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[Any], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[Any], sqlalchemy.sql.roles.TypedColumnsClauseRole[Any], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), Any], types: collections.abc.Sequence['_TypeEngineArgument[Any]'] | None = None) -> sqlalchemy.sql.elements.Tuple
sqlmodel.type_coerce
Python Library Documentation: function type_coerce in module sqlmodel.sql.expression
type_coerce(expression: Union[Any, ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[Any], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[Any], sqlalchemy.sql.roles.TypedColumnsClauseRole[Any], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement')], type_: '_TypeEngineArgument[_T]') -> sqlalchemy.sql.elements.TypeCoerce[~_T]
sqlmodel.union
Python Library Documentation: function union in module sqlalchemy.sql._selectable_constructors
union(*selects: '_SelectStatementForCompoundArgument[_TP]') -> 'CompoundSelect[_TP]'
Return a ``UNION`` of multiple selectables.
The returned object is an instance of
:class:`_expression.CompoundSelect`.
A similar :func:`union()` method is available on all
:class:`_expression.FromClause` subclasses.
:param \*selects:
a list of :class:`_expression.Select` instances.
:param \**kwargs:
available keyword arguments are the same as those of
:func:`select`.
sqlmodel.union_all
Python Library Documentation: function union_all in module sqlalchemy.sql._selectable_constructors
union_all(*selects: '_SelectStatementForCompoundArgument[_TP]') -> 'CompoundSelect[_TP]'
Return a ``UNION ALL`` of multiple selectables.
The returned object is an instance of
:class:`_expression.CompoundSelect`.
A similar :func:`union_all()` method is available on all
:class:`_expression.FromClause` subclasses.
:param \*selects:
a list of :class:`_expression.Select` instances.
sqlmodel.update
Python Library Documentation: function update in module sqlalchemy.sql._dml_constructors
update(table: '_DMLTableArgument') -> 'Update'
Construct an :class:`_expression.Update` object.
E.g.::
from sqlalchemy import update
stmt = (
update(user_table).where(user_table.c.id == 5).values(name="user #5")
)
Similar functionality is available via the
:meth:`_expression.TableClause.update` method on
:class:`_schema.Table`.
:param table: A :class:`_schema.Table`
object representing the database
table to be updated.
.. seealso::
:ref:`tutorial_core_update_delete` - in the :ref:`unified_tutorial`
sqlmodel.values
Python Library Documentation: function values in module sqlalchemy.sql._selectable_constructors
values(*columns: '_OnlyColumnArgument[Any]', name: 'Optional[str]' = None, literal_binds: 'bool' = False) -> 'Values'
Construct a :class:`_expression.Values` construct representing the
SQL ``VALUES`` clause.
The column expressions and the actual data for :class:`_expression.Values`
are given in two separate steps. The constructor receives the column
expressions typically as :func:`_expression.column` constructs, and the
data is then passed via the :meth:`_expression.Values.data` method as a
list, which can be called multiple times to add more data, e.g.::
from sqlalchemy import column
from sqlalchemy import values
from sqlalchemy import Integer
from sqlalchemy import String
value_expr = (
values(
column("id", Integer),
column("name", String),
)
.data([(1, "name1"), (2, "name2")])
.data([(3, "name3")])
)
Would represent a SQL fragment like::
VALUES(1, "name1"), (2, "name2"), (3, "name3")
The :class:`_sql.values` construct has an optional
:paramref:`_sql.values.name` field; when using this field, the
PostgreSQL-specific "named VALUES" clause may be generated::
value_expr = values(
column("id", Integer), column("name", String), name="somename"
).data([(1, "name1"), (2, "name2"), (3, "name3")])
When selecting from the above construct, the name and column names will
be listed out using a PostgreSQL-specific syntax::
>>> print(value_expr.select())
SELECT somename.id, somename.name
FROM (VALUES (:param_1, :param_2), (:param_3, :param_4),
(:param_5, :param_6)) AS somename (id, name)
For a more database-agnostic means of SELECTing named columns from a
VALUES expression, the :meth:`.Values.cte` method may be used, which
produces a named CTE with explicit column names against the VALUES
construct within; this syntax works on PostgreSQL, SQLite, and MariaDB::
value_expr = (
values(
column("id", Integer),
column("name", String),
)
.data([(1, "name1"), (2, "name2"), (3, "name3")])
.cte()
)
Rendering as::
>>> print(value_expr.select())
WITH anon_1(id, name) AS
(VALUES (:param_1, :param_2), (:param_3, :param_4), (:param_5, :param_6))
SELECT anon_1.id, anon_1.name
FROM anon_1
.. versionadded:: 2.0.42 Added the :meth:`.Values.cte` method to
:class:`.Values`
:param \*columns: column expressions, typically composed using
:func:`_expression.column` objects.
:param name: the name for this VALUES construct. If omitted, the
VALUES construct will be unnamed in a SQL expression. Different
backends may have different requirements here.
:param literal_binds: Defaults to False. Whether or not to render
the data values inline in the SQL output, rather than using bound
parameters.
sqlmodel.within_group
Python Library Documentation: function within_group in module sqlmodel.sql.expression
within_group(element: sqlalchemy.sql.functions.FunctionElement[~_T], *order_by: Union[ForwardRef('ColumnElement[_T]'), sqlalchemy.sql._typing._HasClauseElement[Any], ForwardRef('SQLCoreOperations[_T]'), sqlalchemy.sql.roles.ExpressionElementRole[Any], sqlalchemy.sql.roles.TypedColumnsClauseRole[Any], Callable[[], ForwardRef('ColumnElement[_T]')], ForwardRef('LambdaElement'), Any]) -> sqlalchemy.sql.elements.WithinGroup[~_T]