class Numeric(HasExpressionLookup, TypeEngine[
Known subclasses: sqlalchemy.dialects.oracle.NUMBER
, sqlalchemy.dialects.postgresql.asyncpg.AsyncpgNumeric
, sqlalchemy.sql.sqltypes.DECIMAL
, sqlalchemy.sql.sqltypes.Float
, sqlalchemy.sql.sqltypes.NUMERIC
, sqlalchemy.dialects.mssql.pymssql._MSNumeric_pymssql
, sqlalchemy.dialects.mssql.pyodbc._MSNumeric_pyodbc
, sqlalchemy.dialects.oracle.cx_oracle._OracleNumeric
, sqlalchemy.dialects.postgresql._psycopg_common._PsycopgNumeric
, sqlalchemy.dialects.postgresql.pg8000._PGNumeric
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 | __init__ |
Construct a Numeric. |
Method | bind |
Return a conversion function for processing bind values. |
Method | get |
Return the corresponding type object from the underlying DB-API, if any. |
Method | literal |
Return a conversion function for processing literal values that are to be rendered directly without using binds. |
Method | result |
Return a conversion function for processing result row values. |
Class Variable | __visit |
Undocumented |
Instance Variable | asdecimal |
Undocumented |
Instance Variable | decimal |
Undocumented |
Instance Variable | precision |
Undocumented |
Instance Variable | scale |
Undocumented |
Property | python |
Return the Python type object expected to be returned by instances of this type, if known. |
Class Variable | _default |
Undocumented |
Property | _effective |
Undocumented |
Property | _expression |
Undocumented |
Property | _type |
Return a rudimental 'affinity' value expressing the general class of type. |
Inherited from HasExpressionLookup
:
Class |
|
Undocumented |
Inherited from TypeEngineMixin
(via HasExpressionLookup
):
Method | adapt |
Undocumented |
Method | dialect |
Undocumented |
Class Variable | __slots__ |
Undocumented |
Property | _static |
Undocumented |
Inherited from TypeEngine
(via HasExpressionLookup
, TypeEngineMixin
):
Method | __repr__ |
Undocumented |
Method | __str__ |
Undocumented |
Method | as |
Return an instance of the generic type corresponding to this type using heuristic rule. The method may be overridden if this heuristic rule is not sufficient. |
Method | bind |
Given a bind value (i.e. a :class:`.BindParameter` instance), return a SQL expression in its place. |
Method | coerce |
Suggest a type for a 'coerced' Python value in an expression. |
Method | column |
Given a SELECT column expression, return a wrapping SQL expression. |
Method | compare |
Compare this type against the given backend type. |
Method | compare |
Compare two values for equality. |
Method | compile |
Produce a string-compiled form of this :class:`.TypeEngine`. |
Method | copy |
Undocumented |
Method | copy |
Undocumented |
Method | evaluates |
Return a copy of this type which has the :attr:`.should_evaluate_none` flag set to True. |
Method | with |
Produce a copy of this type object that will utilize the given type when applied to the dialect of the given name. |
Class Variable | hashable |
Flag, if False, means values from this type aren't hashable. |
Class Variable | render |
Render bind casts for :attr:`.BindTyping.RENDER_CASTS` mode. |
Class Variable | render |
render casts when rendering a value as an inline literal, e.g. with :meth:`.TypeEngine.literal_processor`. |
Class Variable | should |
If True, the Python constant ``None`` is considered to be handled explicitly by this type. |
Class Variable | sort |
A sorting function that can be passed as the key to sorted. |
Static Method | _to |
Undocumented |
Method | _cached |
Return a dialect-specific bind processor for this type. |
Method | _cached |
return a dialect-specific processing object for custom purposes. |
Method | _cached |
Return a dialect-specific literal processor for this type. |
Method | _cached |
Return a dialect-specific result processor for this type. |
Method | _compare |
Undocumented |
Method | _default |
Undocumented |
Method | _dialect |
Return a dialect-specific registry which caches a dialect-specific implementation, bind processing function, and one or more result processing functions. |
Method | _gen |
Undocumented |
Method | _resolve |
adjust this type given a literal Python value that will be stored in a bound parameter. |
Method | _resolve |
given a Python type (e.g. ``int``, ``str``, etc. ) return an instance of this :class:`.TypeEngine` that's appropriate for this type. |
Method | _unwrapped |
Return the 'unwrapped' dialect impl for this type. |
Class Variable | _is |
Undocumented |
Class Variable | _is |
Undocumented |
Class Variable | _is |
Undocumented |
Class Variable | _is |
Undocumented |
Class Variable | _isnull |
Undocumented |
Class Variable | _sqla |
Undocumented |
Property | _generic |
Undocumented |
Property | _has |
memoized boolean, check if bind_expression is implemented. |
Property | _has |
memoized boolean, check if column_expression is implemented. |
Inherited from Visitable
(via HasExpressionLookup
, TypeEngineMixin
, TypeEngine
):
Method | __class |
Undocumented |
Method | __init |
Undocumented |
Class Method | _generate |
Undocumented |
Method | _compiler |
Undocumented |
Class Variable | _original |
Undocumented |
Numeric[ decimal.Decimal]
, precision: Optional[ int]
= ..., scale: Optional[ int]
= ..., decimal_return_scale: Optional[ int]
= ..., asdecimal: Literal[ True]
= ...):Numeric[ float]
, precision: Optional[ int]
= ..., scale: Optional[ int]
= ..., decimal_return_scale: Optional[ int]
= ..., asdecimal: Literal[ False]
= ...):sqlalchemy.dialects.mysql.DECIMAL
, sqlalchemy.dialects.mysql.NUMERIC
, sqlalchemy.dialects.oracle.NUMBER
, sqlalchemy.sql.sqltypes.Float
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.
sqlalchemy.dialects.mysql.FLOAT
, sqlalchemy.dialects.mysql.FLOAT
, sqlalchemy.dialects.postgresql.asyncpg.AsyncpgNumeric
, sqlalchemy.dialects.oracle.cx_oracle._OracleNumeric
, sqlalchemy.dialects.postgresql._psycopg_common._PsycopgNumeric
, sqlalchemy.dialects.postgresql.pg8000._PGNumericNoBind
Return a conversion function for processing bind values. Returns a callable which will receive a bind parameter value as the sole positional argument and will return a value to send to the DB-API. If processing is not necessary, the method should return ``None``. .. note:: This method is only called relative to a **dialect specific type object**, which is often **private to a dialect in use** and is not the same type object as the public facing one, which means it's not feasible to subclass a :class:`.types.TypeEngine` class in order to provide an alternate :meth:`_types.TypeEngine.bind_processor` method, unless subclassing the :class:`_types.UserDefinedType` class explicitly. To provide alternate behavior for :meth:`_types.TypeEngine.bind_processor`, implement a :class:`_types.TypeDecorator` class and provide an implementation of :meth:`_types.TypeDecorator.process_bind_param`. .. seealso:: :ref:`types_typedecorator` :param dialect: Dialect instance in use.
sqlalchemy.dialects.oracle.cx_oracle._OracleBinaryFloat
Return the corresponding type object from the underlying DB-API, if any. This can be useful for calling ``setinputsizes()``, for example.
Return a conversion function for processing literal values that are to be rendered directly without using binds. This function is used when the compiler makes use of the "literal_binds" flag, typically used in DDL generation as well as in certain scenarios where backends don't accept bound parameters. Returns a callable which will receive a literal Python value as the sole positional argument and will return a string representation to be rendered in a SQL statement. .. note:: This method is only called relative to a **dialect specific type object**, which is often **private to a dialect in use** and is not the same type object as the public facing one, which means it's not feasible to subclass a :class:`.types.TypeEngine` class in order to provide an alternate :meth:`_types.TypeEngine.literal_processor` method, unless subclassing the :class:`_types.UserDefinedType` class explicitly. To provide alternate behavior for :meth:`_types.TypeEngine.literal_processor`, implement a :class:`_types.TypeDecorator` class and provide an implementation of :meth:`_types.TypeDecorator.process_literal_param`. .. seealso:: :ref:`types_typedecorator`
sqlalchemy.dialects.postgresql.asyncpg.AsyncpgNumeric
, sqlalchemy.sql.sqltypes.Float
, sqlalchemy.dialects.mssql.pymssql._MSNumeric_pymssql
, sqlalchemy.dialects.oracle.cx_oracle._OracleNumeric
, sqlalchemy.dialects.postgresql._psycopg_common._PsycopgNumeric
, sqlalchemy.dialects.postgresql.pg8000._PGNumeric
Return a conversion function for processing result row values. Returns a callable which will receive a result row column value as the sole positional argument and will return a value to return to the user. If processing is not necessary, the method should return ``None``. .. note:: This method is only called relative to a **dialect specific type object**, which is often **private to a dialect in use** and is not the same type object as the public facing one, which means it's not feasible to subclass a :class:`.types.TypeEngine` class in order to provide an alternate :meth:`_types.TypeEngine.result_processor` method, unless subclassing the :class:`_types.UserDefinedType` class explicitly. To provide alternate behavior for :meth:`_types.TypeEngine.result_processor`, implement a :class:`_types.TypeDecorator` class and provide an implementation of :meth:`_types.TypeDecorator.process_result_value`. .. seealso:: :ref:`types_typedecorator` :param dialect: Dialect instance in use. :param coltype: DBAPI coltype argument received in cursor.description.
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.
sqlalchemy.dialects.oracle.NUMBER
Return a rudimental 'affinity' value expressing the general class of type.