# sql/sqltypes.py

# Copyright (C) 2005-2019 the SQLAlchemy authors and contributors

# <see AUTHORS file>

#

# This module is part of SQLAlchemy and is released under

# the MIT License: http://www.opensource.org/licenses/mit-license.php

"""SQL specific types.

"""

import codecs

import datetime as dt

import decimal

import json

from . import coercions

from . import elements

from . import operators

from . import roles

from . import type_api

from .base import _bind_or_error

from .base import SchemaEventTarget

from .elements import _defer_name

from .elements import quoted_name

from .elements import Slice

from .elements import TypeCoerce as type_coerce # noqa

from .type_api import Emulated

from .type_api import NativeForEmulated # noqa

from .type_api import to_instance

from .type_api import TypeDecorator

from .type_api import TypeEngine

from .type_api import Variant

from .. import event

from .. import exc

from .. import inspection

from .. import processors

from .. import util

from ..util import compat

from ..util import pickle

if util.jython:

import array

class _LookupExpressionAdapter(object):

"""Mixin expression adaptations based on lookup tables.

These rules are currenly used by the numeric, integer and date types

which have detailed cross-expression coercion rules.

"""

@property

def _expression_adaptations(self):

raise NotImplementedError()

class Comparator(TypeEngine.Comparator):

_blank_dict = util.immutabledict()

def _adapt_expression(self, op, other_comparator):

othertype = other_comparator.type._type_affinity

lookup = self.type._expression_adaptations.get(

op, self._blank_dict

).get(othertype, self.type)

if lookup is othertype:

return (op, other_comparator.type)

elif lookup is self.type._type_affinity:

return (op, self.type)

else:

return (op, to_instance(lookup))

comparator_factory = Comparator

class Concatenable(object):

"""A mixin that marks a type as supporting 'concatenation',

typically strings."""

class Comparator(TypeEngine.Comparator):

def _adapt_expression(self, op, other_comparator):

if op is operators.add and isinstance(

other_comparator,

(Concatenable.Comparator, NullType.Comparator),

):

return operators.concat_op, self.expr.type

else:

return super(Concatenable.Comparator, self)._adapt_expression(

op, other_comparator

)

comparator_factory = Comparator

class Indexable(object):

"""A mixin that marks a type as supporting indexing operations,

such as array or JSON structures.

.. versionadded:: 1.1.0

"""

class Comparator(TypeEngine.Comparator):

def _setup_getitem(self, index):

raise NotImplementedError()

def __getitem__(self, index):

(

adjusted_op,

adjusted_right_expr,

result_type,

) = self._setup_getitem(index)

return self.operate(

adjusted_op, adjusted_right_expr, result_type=result_type

)

comparator_factory = Comparator

class String(Concatenable, TypeEngine):

"""The base for all string and character types.

In SQL, corresponds to VARCHAR. Can also take Python unicode objects

and encode to the database's encoding in bind params (and the reverse for

result sets.)

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.

"""

__visit_name__ = "string"

@util.deprecated_params(

convert_unicode=(

"1.3",

"The :paramref:`.String.convert_unicode` parameter is deprecated "

"and will be removed in a future release. All modern DBAPIs "

"now support Python Unicode directly and this parameter is "

"unnecessary.",

),

unicode_error=(

"1.3",

"The :paramref:`.String.unicode_errors` parameter is deprecated "

"and will be removed in a future release. This parameter is "

"unnecessary for modern Python DBAPIs and degrades performance "

"significantly.",

),

)

def __init__(

self,

length=None,

collation=None,

convert_unicode=False,

unicode_error=None,

_warn_on_bytestring=False,

_expect_unicode=False,

):

"""

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.::

>>> from sqlalchemy import cast, select, String

>>> print select([cast('some string', String(collation='utf8'))])

SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1

:param convert_unicode: When set to ``True``, the

:class:`.String` type will assume that

input is to be passed as Python Unicode objects under Python 2,

and results returned as Python Unicode objects.

In the rare circumstance that the DBAPI does not support

Python unicode under Python 2, SQLAlchemy will use its own

encoder/decoder functionality on strings, referring to the

value of the :paramref:`.create_engine.encoding` parameter

parameter passed to :func:`.create_engine` as the encoding.

For the extremely rare case that Python Unicode

is to be encoded/decoded by SQLAlchemy on a backend

that *does* natively support Python Unicode,

the string value ``"force"`` can be passed here which will

cause SQLAlchemy's encode/decode services to be

used unconditionally.

.. note::

SQLAlchemy's unicode-conversion flags and features only apply

to Python 2; in Python 3, all string objects are Unicode objects.

For this reason, as well as the fact that virtually all modern

DBAPIs now support Unicode natively even under Python 2,

the :paramref:`.String.convert_unicode` flag is inherently a

legacy feature.

.. note::

In the vast majority of cases, the :class:`.Unicode` or

:class:`.UnicodeText` datatypes should be used for a

:class:`.Column` that expects to store non-ascii data. These

datatypes will ensure that the correct types are used on the

database side as well as set up the correct Unicode behaviors

under Python 2.

.. seealso::

:paramref:`.create_engine.convert_unicode` -

:class:`.Engine`-wide parameter

:param unicode_error: Optional, a method to use to handle Unicode

conversion errors. Behaves like the ``errors`` keyword argument to

the standard library's ``string.decode()`` functions, requires

that :paramref:`.String.convert_unicode` is set to

``"force"``

"""

if unicode_error is not None and convert_unicode != "force":

raise exc.ArgumentError(

"convert_unicode must be 'force' " "when unicode_error is set."

)

self.length = length

self.collation = collation

self._expect_unicode = convert_unicode or _expect_unicode

self._expect_unicode_error = unicode_error

self._warn_on_bytestring = _warn_on_bytestring

def literal_processor(self, dialect):

def process(value):

value = value.replace("'", "''")

if dialect.identifier_preparer._double_percents:

value = value.replace("%", "%%")

return "'%s'" % value

return process

def bind_processor(self, dialect):

if self._expect_unicode or dialect.convert_unicode:

if (

dialect.supports_unicode_binds

and self._expect_unicode != "force"

):

if self._warn_on_bytestring:

def process(value):

if isinstance(value, util.binary_type):

util.warn_limited(

"Unicode type received non-unicode "

"bind param value %r.",

(util.ellipses_string(value),),

)

return value

return process

else:

return None

else:

encoder = codecs.getencoder(dialect.encoding)

warn_on_bytestring = self._warn_on_bytestring

def process(value):

if isinstance(value, util.text_type):

return encoder(value, self._expect_unicode_error)[0]

elif warn_on_bytestring and value is not None:

util.warn_limited(

"Unicode type received non-unicode bind "

"param value %r.",

(util.ellipses_string(value),),

)

return value

return process

else:

return None

def result_processor(self, dialect, coltype):

wants_unicode = self._expect_unicode or dialect.convert_unicode

needs_convert = wants_unicode and (

dialect.returns_unicode_strings is not True

or self._expect_unicode in ("force", "force_nocheck")

)

needs_isinstance = (

needs_convert

and dialect.returns_unicode_strings

and self._expect_unicode != "force_nocheck"

)

if needs_convert:

if needs_isinstance:

return processors.to_conditional_unicode_processor_factory(

dialect.encoding, self._expect_unicode_error

)

else:

return processors.to_unicode_processor_factory(

dialect.encoding, self._expect_unicode_error

)

else:

return None

@property

def python_type(self):

if self._expect_unicode:

return util.text_type

else:

return str

def get_dbapi_type(self, dbapi):

return dbapi.STRING

@classmethod

def _warn_deprecated_unicode(cls):

util.warn_deprecated(

"The convert_unicode on Engine and String as well as the "

"unicode_error flag on String are deprecated. All modern "

"DBAPIs now support Python Unicode natively under Python 2, and "

"under Python 3 all strings are inherently Unicode. These flags "

"will be removed in a future release."

)

class Text(String):

"""A variably sized string type.

In SQL, usually corresponds to CLOB or TEXT. Can also take Python

unicode objects and encode to the database's encoding in bind

params (and the reverse for result sets.) In general, TEXT objects

do not have a length; while some databases will accept a length

argument here, it will be rejected by others.

"""

__visit_name__ = "text"

class Unicode(String):

"""A variable length Unicode string type.

The :class:`.Unicode` type is a :class:`.String` subclass

that assumes input and output as Python ``unicode`` data,

and in that regard is equivalent to the usage of the

``convert_unicode`` flag with the :class:`.String` type.

However, unlike plain :class:`.String`, it also implies an

underlying column type that is explicitly supporting of non-ASCII

data, such as ``NVARCHAR`` on Oracle and SQL Server.

This can impact the output of ``CREATE TABLE`` statements

and ``CAST`` functions at the dialect level, and can

also affect the handling of bound parameters in some

specific DBAPI scenarios.

The encoding used by the :class:`.Unicode` type is usually

determined by the DBAPI itself; most modern DBAPIs

feature support for Python ``unicode`` objects as bound

values and result set values, and the encoding should

be configured as detailed in the notes for the target

DBAPI in the :ref:`dialect_toplevel` section.

For those DBAPIs which do not support, or are not configured

to accommodate Python ``unicode`` objects

directly, SQLAlchemy does the encoding and decoding

outside of the DBAPI. The encoding in this scenario

is determined by the ``encoding`` flag passed to

:func:`.create_engine`.

When using the :class:`.Unicode` type, it is only appropriate

to pass Python ``unicode`` objects, and not plain ``str``.

If a plain ``str`` is passed under Python 2, a warning

is emitted. If you notice your application emitting these warnings but

you're not sure of the source of them, the Python

``warnings`` filter, documented at

http://docs.python.org/library/warnings.html,

can be used to turn these warnings into exceptions

which will illustrate a stack trace::

import warnings

warnings.simplefilter('error')

For an application that wishes to pass plain bytestrings

and Python ``unicode`` objects to the ``Unicode`` type

equally, the bytestrings must first be decoded into

unicode. The recipe at :ref:`coerce_to_unicode` illustrates

how this is done.

.. seealso::

:class:`.UnicodeText` - unlengthed textual counterpart

to :class:`.Unicode`.

"""

__visit_name__ = "unicode"

def __init__(self, length=None, **kwargs):

"""

Create a :class:`.Unicode` object.

Parameters are the same as that of :class:`.String`,

with the exception that ``convert_unicode``

defaults to ``True``.

"""

kwargs.setdefault("_expect_unicode", True)

kwargs.setdefault("_warn_on_bytestring", True)

super(Unicode, self).__init__(length=length, **kwargs)

class UnicodeText(Text):

"""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``.

"""

__visit_name__ = "unicode_text"

def __init__(self, length=None, **kwargs):

"""

Create a Unicode-converting Text type.

Parameters are the same as that of :class:`.Text`,

with the exception that ``convert_unicode``

defaults to ``True``.

"""

kwargs.setdefault("_expect_unicode", True)

kwargs.setdefault("_warn_on_bytestring", True)

super(UnicodeText, self).__init__(length=length, **kwargs)

def _warn_deprecated_unicode(self):

pass

class Integer(_LookupExpressionAdapter, TypeEngine):

"""A type for ``int`` integers."""

__visit_name__ = "integer"

def get_dbapi_type(self, dbapi):

return dbapi.NUMBER

@property

def python_type(self):

return int

def literal_processor(self, dialect):

def process(value):

return str(value)

return process

@util.memoized_property

def _expression_adaptations(self):

# TODO: need a dictionary object that will

# handle operators generically here, this is incomplete

return {

operators.add: {

Date: Date,

Integer: self.__class__,

Numeric: Numeric,

},

operators.mul: {

Interval: Interval,

Integer: self.__class__,

Numeric: Numeric,

},

operators.div: {Integer: self.__class__, Numeric: Numeric},

operators.truediv: {Integer: self.__class__, Numeric: Numeric},

operators.sub: {Integer: self.__class__, Numeric: Numeric},

}

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.

"""

__visit_name__ = "small_integer"

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.

"""

__visit_name__ = "big_integer"

class Numeric(_LookupExpressionAdapter, TypeEngine):

"""A type for fixed precision numbers, such as ``NUMERIC`` or ``DECIMAL``.

This type returns Python ``decimal.Decimal`` objects by default, unless

the :paramref:`.Numeric.asdecimal` flag is set to False, in which case

they are coerced to Python ``float`` objects.

.. note::

The :class:`.Numeric` type is designed to receive data from a database

type that is explicitly known to be a decimal type

(e.g. ``DECIMAL``, ``NUMERIC``, others) and not a floating point

type (e.g. ``FLOAT``, ``REAL``, others).

If the database column on the server is in fact a floating-point type

type, such as ``FLOAT`` or ``REAL``, use the :class:`.Float`

type or a subclass, otherwise numeric coercion between

``float``/``Decimal`` may or may not function as expected.

.. note::

The Python ``decimal.Decimal`` class is generally slow

performing; cPython 3.3 has now switched to use the `cdecimal

<http://pypi.python.org/pypi/cdecimal/>`_ library natively. For

older Python versions, the ``cdecimal`` library can be patched

into any application where it will replace the ``decimal``

library fully, however this needs to be applied globally and

before any other modules have been imported, as follows::

import sys

import cdecimal

sys.modules["decimal"] = cdecimal

Note that the ``cdecimal`` and ``decimal`` libraries are **not

compatible with each other**, so patching ``cdecimal`` at the

global level is the only way it can be used effectively with

various DBAPIs that hardcode to import the ``decimal`` library.

"""

__visit_name__ = "numeric"

_default_decimal_return_scale = 10

def __init__(

self,

precision=None,

scale=None,

decimal_return_scale=None,

asdecimal=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.

.. versionadded:: 0.9.0

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.

"""

self.precision = precision

self.scale = scale

self.decimal_return_scale = decimal_return_scale

self.asdecimal = asdecimal

@property

def _effective_decimal_return_scale(self):

if self.decimal_return_scale is not None:

return self.decimal_return_scale

elif getattr(self, "scale", None) is not None:

return self.scale

else:

return self._default_decimal_return_scale

def get_dbapi_type(self, dbapi):

return dbapi.NUMBER

def literal_processor(self, dialect):

def process(value):

return str(value)

return process

@property

def python_type(self):

if self.asdecimal:

return decimal.Decimal

else:

return float

def bind_processor(self, dialect):

if dialect.supports_native_decimal:

return None

else:

return processors.to_float

def result_processor(self, dialect, coltype):

if self.asdecimal:

if dialect.supports_native_decimal:

# we're a "numeric", DBAPI will give us Decimal directly

return None

else:

util.warn(

"Dialect %s+%s does *not* support Decimal "

"objects natively, and SQLAlchemy must "

"convert from floating point - rounding "

"errors and other issues may occur. Please "

"consider storing Decimal numbers as strings "

"or integers on this platform for lossless "

"storage." % (dialect.name, dialect.driver)

)

# we're a "numeric", DBAPI returns floats, convert.

return processors.to_decimal_processor_factory(

decimal.Decimal,

self.scale

if self.scale is not None

else self._default_decimal_return_scale,

)

else:

if dialect.supports_native_decimal:

return processors.to_float

else:

return None

@util.memoized_property

def _expression_adaptations(self):

return {

operators.mul: {

Interval: Interval,

Numeric: self.__class__,

Integer: self.__class__,

},

operators.div: {Numeric: self.__class__, Integer: self.__class__},

operators.truediv: {

Numeric: self.__class__,

Integer: self.__class__,

},

operators.add: {Numeric: self.__class__, Integer: self.__class__},

operators.sub: {Numeric: self.__class__, Integer: self.__class__},

}

class Float(Numeric):

"""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.

.. note::

The :class:`.Float` type is designed to receive data from a database

type that is explicitly known to be a floating point type

(e.g. ``FLOAT``, ``REAL``, others)

and not a decimal type (e.g. ``DECIMAL``, ``NUMERIC``, others).

If the database column on the server is in fact a Numeric

type, such as ``DECIMAL`` or ``NUMERIC``, use the :class:`.Numeric`

type or a subclass, otherwise numeric coercion between

``float``/``Decimal`` may or may not function as expected.

"""

__visit_name__ = "float"

scale = None

def __init__(

self, precision=None, asdecimal=False, decimal_return_scale=None

):

r"""

Construct a Float.

:param precision: the numeric precision for use in DDL ``CREATE

TABLE``.

: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.

.. versionadded:: 0.9.0

"""

self.precision = precision

self.asdecimal = asdecimal

self.decimal_return_scale = decimal_return_scale

def result_processor(self, dialect, coltype):

if self.asdecimal:

return processors.to_decimal_processor_factory(

decimal.Decimal, self._effective_decimal_return_scale

)

elif dialect.supports_native_decimal:

return processors.to_float

else:

return None

class DateTime(_LookupExpressionAdapter, TypeEngine):

"""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.

"""

__visit_name__ = "datetime"

def __init__(self, timezone=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.

"""

self.timezone = timezone

def get_dbapi_type(self, dbapi):

return dbapi.DATETIME

@property

def python_type(self):

return dt.datetime

@util.memoized_property

def _expression_adaptations(self):

# Based on http://www.postgresql.org/docs/current/\

# static/functions-datetime.html.

return {

operators.add: {Interval: self.__class__},

operators.sub: {Interval: self.__class__, DateTime: Interval},

}

class Date(_LookupExpressionAdapter, TypeEngine):

"""A type for ``datetime.date()`` objects."""

__visit_name__ = "date"

def get_dbapi_type(self, dbapi):

return dbapi.DATETIME

@property

def python_type(self):

return dt.date

@util.memoized_property

def _expression_adaptations(self):

# Based on http://www.postgresql.org/docs/current/\

# static/functions-datetime.html.

return {

operators.add: {

Integer: self.__class__,

Interval: DateTime,

Time: DateTime,

},

operators.sub: {

# date - integer = date

Integer: self.__class__,

# date - date = integer.

Date: Integer,

Interval: DateTime,

# date - datetime = interval,

# this one is not in the PG docs

# but works

DateTime: Interval,

},

}

class Time(_LookupExpressionAdapter, TypeEngine):

"""A type for ``datetime.time()`` objects."""

__visit_name__ = "time"

def __init__(self, timezone=False):

self.timezone = timezone

def get_dbapi_type(self, dbapi):

return dbapi.DATETIME

@property

def python_type(self):

return dt.time

@util.memoized_property

def _expression_adaptations(self):

# Based on http://www.postgresql.org/docs/current/\

# static/functions-datetime.html.

return {

operators.add: {Date: DateTime, Interval: self.__class__},

operators.sub: {Time: Interval, Interval: self.__class__},

}

class _Binary(TypeEngine):

"""Define base behavior for binary types."""

def __init__(self, length=None):

self.length = length

def literal_processor(self, dialect):

def process(value):

value = value.decode(dialect.encoding).replace("'", "''")

return "'%s'" % value

return process

@property

def python_type(self):

return util.binary_type

# Python 3 - sqlite3 doesn't need the `Binary` conversion

# here, though pg8000 does to indicate "bytea"

def bind_processor(self, dialect):

if dialect.dbapi is None:

return None

DBAPIBinary = dialect.dbapi.Binary

def process(value):

if value is not None:

return DBAPIBinary(value)

else:

return None

return process

# Python 3 has native bytes() type

# both sqlite3 and pg8000 seem to return it,

# psycopg2 as of 2.5 returns 'memoryview'

if util.py2k:

def result_processor(self, dialect, coltype):

if util.jython:

def process(value):

if value is not None:

if isinstance(value, array.array):

return value.tostring()

return str(value)

else:

return None

else:

process = processors.to_str

return process

else:

def result_processor(self, dialect, coltype):

def process(value):

if value is not None:

value = bytes(value)

return value

return process

def coerce_compared_value(self, op, value):

"""See :meth:`.TypeEngine.coerce_compared_value` for a description."""

if isinstance(value, util.string_types):

return self

else:

return super(_Binary, self).coerce_compared_value(op, value)

def get_dbapi_type(self, dbapi):

return dbapi.BINARY

class LargeBinary(_Binary):

"""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.

"""

__visit_name__ = "large_binary"

def __init__(self, length=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.

"""

_Binary.__init__(self, length=length)

@util.deprecated_cls(

"0.6",

"The :class:`.Binary` class is deprecated and will be removed "

"in a future relase. Please use :class:`.LargeBinary`.",

)

class Binary(LargeBinary):

def __init__(self, *arg, **kw):

LargeBinary.__init__(self, *arg, **kw)

class SchemaType(SchemaEventTarget):

"""Mark a type as possibly requiring schema-level DDL for usage.

Supports types that must be explicitly created/dropped (i.e. PG ENUM type)

as well as types that are complimented by table or schema level