sqlalchemy.dialects.oracle.NUMBER

class documentation

class NUMBER(sqltypes.Numeric, sqltypes.Integer): (source)

View In Hierarchy

Undocumented

Method __init__ Construct a Numeric.
Method adapt Produce an "adapted" form of this type, given an "impl" class to work with.
Class Variable __visit_name__ Undocumented
Property _type_affinity Return a rudimental 'affinity' value expressing the general class of type.

Inherited from Numeric:

Method bind_processor Return a conversion function for processing bind values.
Method get_dbapi_type Return the corresponding type object from the underlying DB-API, if any.
Method literal_processor Return a conversion function for processing literal values that are to be rendered directly without using binds.
Method result_processor Return a conversion function for processing result row values.
Instance Variable asdecimal Undocumented
Instance Variable decimal_return_scale Undocumented
Instance Variable precision Undocumented
Instance Variable scale Undocumented
Property python_type Return the Python type object expected to be returned by instances of this type, if known.
Class Variable _default_decimal_return_scale Undocumented
Property _effective_decimal_return_scale Undocumented
Property _expression_adaptations Undocumented

Inherited from Integer (via Numeric):

Method _resolve_for_literal adjust this type given a literal Python value that will be stored in a bound parameter.

Inherited from HasExpressionLookup (via Numeric, Integer):

Class Comparator Undocumented

Inherited from TypeEngineMixin (via Numeric, Integer, HasExpressionLookup):

Method dialect_impl Undocumented
Class Variable __slots__ Undocumented
Property _static_cache_key Undocumented

Inherited from TypeEngine (via Numeric, Integer, HasExpressionLookup, TypeEngineMixin):

Method __repr__ Undocumented
Method __str__ Undocumented
Method as_generic Return an instance of the generic type corresponding to this type using heuristic rule. The method may be overridden if this heuristic rule is not sufficient.
Method bind_expression Given a bind value (i.e. a :class:`.BindParameter` instance), return a SQL expression in its place.
Method coerce_compared_value Suggest a type for a 'coerced' Python value in an expression.
Method column_expression Given a SELECT column expression, return a wrapping SQL expression.
Method compare_against_backend Compare this type against the given backend type.
Method compare_values Compare two values for equality.
Method compile Produce a string-compiled form of this :class:`.TypeEngine`.
Method copy Undocumented
Method copy_value Undocumented
Method evaluates_none Return a copy of this type which has the :attr:`.should_evaluate_none` flag set to True.
Method with_variant Produce a copy of this type object that will utilize the given type when applied to the dialect of the given name.
Class Variable hashable Flag, if False, means values from this type aren't hashable.
Class Variable render_bind_cast Render bind casts for :attr:`.BindTyping.RENDER_CASTS` mode.
Class Variable render_literal_cast render casts when rendering a value as an inline literal, e.g. with :meth:`.TypeEngine.literal_processor`.
Class Variable should_evaluate_none If True, the Python constant ``None`` is considered to be handled explicitly by this type.
Class Variable sort_key_function A sorting function that can be passed as the key to sorted.
Static Method _to_instance Undocumented
Method _cached_bind_processor Return a dialect-specific bind processor for this type.
Method _cached_custom_processor return a dialect-specific processing object for custom purposes.
Method _cached_literal_processor Return a dialect-specific literal processor for this type.
Method _cached_result_processor Return a dialect-specific result processor for this type.
Method _compare_type_affinity Undocumented
Method _default_dialect Undocumented
Method _dialect_info Return a dialect-specific registry which caches a dialect-specific implementation, bind processing function, and one or more result processing functions.
Method _gen_dialect_impl Undocumented
Method _resolve_for_python_type given a Python type (e.g. ``int``, ``str``, etc. ) return an instance of this :class:`.TypeEngine` that's appropriate for this type.
Method _unwrapped_dialect_impl Return the 'unwrapped' dialect impl for this type.
Class Variable _is_array Undocumented
Class Variable _is_table_value Undocumented
Class Variable _is_tuple_type Undocumented
Class Variable _is_type_decorator Undocumented
Class Variable _isnull Undocumented
Class Variable _sqla_type Undocumented
Property _generic_type_affinity Undocumented
Property _has_bind_expression memoized boolean, check if bind_expression is implemented.
Property _has_column_expression memoized boolean, check if column_expression is implemented.

Inherited from Visitable (via Numeric, Integer, HasExpressionLookup, TypeEngineMixin, TypeEngine):

Method __class_getitem__ Undocumented
Method __init_subclass__ Undocumented
Class Method _generate_compiler_dispatch Undocumented
Method _compiler_dispatch Undocumented
Class Variable _original_compiler_dispatch Undocumented
def __init__(self, precision=None, scale=None, asdecimal=None): (source)
overrides sqlalchemy.sql.sqltypes.Numeric.__init__

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.

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

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

__visit_name__: str = (source)
overrides sqlalchemy.sql.sqltypes.Numeric.__visit_name__

Undocumented

@property
_type_affinity = (source)
overrides sqlalchemy.sql.sqltypes.Numeric._type_affinity

Return a rudimental 'affinity' value expressing the general class of type.