SQLAlchemy为最常见的数据库数据类型提供了抽象，并提供了一种指定您自己的自定义数据类型的机制。
类型对象的方法和属性很少直接使用。类型对象提供给 Table 定义和可以作为类型提示提供给 functions 对于数据库驱动程序返回错误类型的情况。
>>> users = Table('users', metadata,
... Column('id', Integer, primary_key=True),
... Column('login', String(32))
... )SQL炼金术将使用 Integer 和 String(32) 发布时键入信息 CREATE TABLE 语句，并在读回行时再次使用它 SELECTed 从数据库中。接受类型的函数（例如 Column() ）通常接受类型类或实例； Integer 等于 Integer() 在本例中没有构造参数。
泛型类型指定可以读取、写入和存储特定类型的Python数据的列。当发出一个 CREATE TABLE 语句。用于完全控制在哪个列类型中发出 CREATE TABLE ，如 VARCHAR 看见 SQL标准和多个供应商类型 以及本章的其他章节。
| Object Name | Description |
|---|---|
一种更大的 |
|
bool数据类型。 |
|
一种类型 |
|
一种类型 |
|
通用枚举类型。 |
|
表示浮点类型的类型，例如 |
|
一种类型 |
|
一种类型 |
|
用于大二进制字节数据的类型。 |
|
引用match运算符的返回类型。 |
|
用于固定精度数字的类型，例如 |
|
保存使用pickle序列化的python对象。 |
|
将类型标记为可能需要架构级DDL才能使用。 |
|
较小的一种 |
|
所有字符串和字符类型的基。 |
|
大小可变的字符串类型。 |
|
一种类型 |
|
长度可变的Unicode字符串类型。 |
|
无限长的Unicode字符串类型。 |
一种更大的 int 整数。
通常会生成 BIGINT 在DDL中，否则行为就像正常的 Integer 在 Python 这边。
类签名
class sqlalchemy.types.BigInteger (sqlalchemy.types.Integer)
bool数据类型。
Boolean 通常在DDL端使用boolean或smallint，在python端处理 True 或 False .
这个 Boolean 数据类型当前有两个断言级别，即持久化的值是简单的真/假值。对于所有后端，只有python值 None ， True ， False ， 1 或 0 作为参数值接受。对于那些不支持“原生布尔”数据类型的后端，存在一个在目标列上创建检查约束的选项
在 1.2 版更改: 这个 Boolean 数据类型现在断言传入的python值已经是纯布尔形式。
类签名
class sqlalchemy.types.Boolean (sqlalchemy.types.Emulated, sqlalchemy.types.TypeEngine, sqlalchemy.types.SchemaType)
sqlalchemy.types.Boolean.__init__(create_constraint=False, name=None, _create_events=True)¶构造一个布尔值。
create_constraint¶ -- 默认为False。如果布尔值是作为int/smallint生成的，那么还要在表上创建一个CHECK约束，以确保1或0作为值。。注意：强烈建议CHECK约束有一个显式的名称，以支持模式管理问题。可以通过设置 Boolean.name 参数或通过设置适当的命名约定；请参阅 配置约束命名约定 作为背景。。versionchanged:：1.4-此标志现在默认为False，这意味着不会为非本机枚举类型生成检查约束。
name¶ -- 如果生成了检查约束，请指定约束的名称。
sqlalchemy.types.Boolean.bind_processor(dialect)¶返回用于处理绑定值的转换函数。
返回一个callable，该callable将接收一个bind参数值作为唯一的位置参数，并返回一个要发送到db-api的值。
如果不需要处理，则该方法应返回 None .
dialect¶ -- 方言实例正在使用中。
sqlalchemy.types.Boolean.literal_processor(dialect)¶返回一个转换函数，用于处理直接呈现而不使用绑定的文本值。
当编译器使用“文本绑定”标志时，通常在生成DDL以及后端不接受绑定参数的某些情况下使用此函数。
0.9.0 新版功能.
sqlalchemy.types.Boolean.python_type¶sqlalchemy.types.Boolean.result_processor(dialect, coltype)¶返回用于处理结果行值的转换函数。
返回一个可调用的，它将接收作为唯一位置参数的结果行列值，并返回一个值以返回给用户。
如果不需要处理，则该方法应返回 None .
一种类型 datetime.date() 物体。
类签名
class sqlalchemy.types.Date (sqlalchemy.types._LookupExpressionAdapter, sqlalchemy.types.TypeEngine)
sqlalchemy.types.Date.get_dbapi_type(dbapi)¶从基础DB-API返回相应的类型对象（如果有）。
这对打电话很有用 setinputsizes() 例如。
sqlalchemy.types.Date.python_type¶一种类型 datetime.datetime() 物体。
日期和时间类型从python返回对象 datetime 模块。大多数DBAPI都内置了对日期时间模块的支持，但注意到了sqlite的例外。对于sqlite，日期和时间类型存储为字符串，然后在返回行时转换回date time对象。
对于日期时间类型中的时间表示，一些后端包括其他选项，例如时区支持和分数秒支持。对于小数秒，使用方言特定的数据类型，例如 TIME . 对于时区支持，至少使用 TIMESTAMP 数据类型，如果不是方言特定的数据类型对象。
类签名
class sqlalchemy.types.DateTime (sqlalchemy.types._LookupExpressionAdapter, sqlalchemy.types.TypeEngine)
sqlalchemy.types.DateTime.__init__(timezone=False)¶构建新的 DateTime .
sqlalchemy.types.DateTime.get_dbapi_type(dbapi)¶从基础DB-API返回相应的类型对象（如果有）。
这对打电话很有用 setinputsizes() 例如。
sqlalchemy.types.DateTime.python_type¶通用枚举类型。
这个 Enum 类型提供一组可能的字符串值，列将被约束到这些值。
这个 Enum 类型将使用后端的本机“ENUM”类型（如果可用）；否则，它将使用VARCHAR数据类型。还存在一个选项，用于在生成VARCHAR（所谓的“非本机”）变量时自动生成CHECK约束；请参见 Enum.create_constraint 旗帜。
这个 Enum 类型还提供了在读写操作期间对字符串值的python验证。从结果集中的数据库中读取值时，始终根据可能值列表和 LookupError 如果找不到匹配项，则引发。在SQL语句中将值作为普通字符串传递到数据库时，如果 Enum.validate_strings 参数设置为true，a LookupError 对于不在给定的可能值列表中的任何字符串值引发；请注意，这会影响对枚举值的LIKE表达式的使用（一个不常见的用例）。
在 1.1 版更改: 这个 Enum 类型现在在python中提供输入值的验证以及数据库返回的数据的验证。
枚举值的来源可以是字符串值列表，也可以是符合PEP-435的枚举类。为了 Enum 数据类型，此类只需要提供 __members__ 方法。
使用枚举类时，枚举对象既用于输入，也用于输出，而不是字符串，就像普通字符串枚举类型那样：
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上面，每个元素的字符串名称（例如“one”、“two”、“three”）被持久化到数据库中；这里表示为整数的python枚举的值是 not 使用；因此，每个枚举的值可以是任何类型的python对象，无论它是否可持久。
为了保持值而不是名称， Enum.values_callable 可以使用参数。此参数的值是用户提供的可调用的，用于符合PEP-435的枚举类，并返回要持久化的字符串值列表。对于使用字符串值的简单枚举，可以调用 lambda x: [e.value for e in x] 就足够了。
1.1 新版功能: -支持PEP-435样式的枚举类。
类签名
class sqlalchemy.types.Enum (sqlalchemy.types.Emulated, sqlalchemy.types.String, sqlalchemy.types.SchemaType)
sqlalchemy.types.Enum.__init__(*enums, **kw)¶构造枚举。
不适用于特定后端的关键字参数将被该后端忽略。
*enums¶ -- 恰好一个符合PEP-435的枚举类型或一个或多个字符串标签。。。VersionAdded：：1.1可以传递PEP-435样式枚举类。
convert_unicode¶ -- 仅在Python2下为此Enum的数据启用Unicode感知的绑定参数和结果集处理。在Python2中，这是根据Unicode标签字符串的存在自动设置的。此标志将在SQLAlChemy 2.0中删除。。。已弃用的：：1.3 Enum.convert_unicode 参数已弃用，并将在将来的版本中删除。所有现代DBAPI现在都直接支持Python Unicode，不需要此参数。
create_constraint¶ -- 默认为False。在创建非本机枚举类型时，还要针对有效值在数据库上生成检查约束。。注意：强烈建议CHECK约束有一个显式的名称，以支持模式管理问题。可以通过设置 Enum.name 参数或通过设置适当的命名约定；请参阅 配置约束命名约定 作为背景。。versionchanged:：1.4-此标志现在默认为False，这意味着不会为非本机枚举类型生成检查约束。
metadata¶ -- 将此类型直接与 MetaData 对象。对于作为独立方案构造(PostgreSQL)存在于目标数据库上的类型，将在中创建并删除此类型 create_all() 和 drop_all() 运营部。如果该类型未与任何 MetaData 对象，它会将自己与每个 Table 在其中使用它，并且将在检查其是否存在之后，在创建这些单独的表中的任何一个时创建它。仅在以下情况下才会删除该类型 drop_all() 都是为此而被召唤的 Table 但是，对象的元数据。的价值 MetaData.schema 属性的参数 MetaData 对象(如果设置)将用作 Enum.schema 如果没有以其他方式提供显式值，则在此对象上返回。。。版本已更改：：1.4.12 Enum 继承 MetaData.schema 属性的参数 MetaData 对象(如果存在)，当使用 Enum.metadata 参数。
name¶ -- 此类型的名称。这对于PostgreSQL和任何未来支持的数据库都是必需的，因为这些数据库需要显式命名的类型或显式命名的约束，以便生成使用它的类型和/或表。如果使用了PEP-435枚举类，则默认使用其名称（转换为小写）。
native_enum¶ -- 使用数据库的本机枚举类型（如果可用）。默认为True。如果为False，则对所有后端使用VARCHAR+check约束。VARCHAR长度可以用 Enum.length
length¶ -- 允许在以下情况下为VARCHAR指定自定义长度 Enum.native_enum 是假的。默认情况下使用最长值。。版本增加：：1.3.16
schema¶ -- 此类型的架构名称。对于作为独立架构构造(PostgreSQL)存在于目标数据库上的类型，此参数指定该类型所在的命名架构。如果不存在，架构名称将从 MetaData 集合(如果作为 Enum.metadata ，对于一个 MetaData 这包括 MetaData.schema 参数。。。版本已更改：：1.4.12 Enum 继承 MetaData.schema 属性的参数 MetaData 对象(如果存在)，当使用 Enum.metadata 参数。否则，如果 Enum.inherit_schema 标志设置为 True ，则该架构将从关联的 Table 对象(如果有)；何时 Enum.inherit_schema 是其缺省的 False ，所属表的模式为 not 使用。
quote¶ -- 为类型的名称设置显式引用首选项。
inherit_schema¶ -- 什么时候？ True ，所属的“架构” Table 将复制到此的“schema”属性 Enum ，替换为 schema 属性。当使用 Table.to_metadata() 操作。
validate_strings¶ -- 如果为true，则将根据枚举值列表检查在SQL语句中传递到数据库的字符串值的有效性。无法识别的值将导致 LookupError 被提升。…添加的版本：1.1.0B2
values_callable¶ -- 将传递符合PEP-435的枚举类型的可调用文件，然后该文件将返回要持久化的字符串值列表。这允许交替使用，例如使用枚举的字符串值来持久化到数据库而不是其名称。…添加版本：1.2.3
sort_key_function¶ -- 一个Python可调用函数，可以用作Python中的“key”参数 sorted() 内置的。SQLAlchemy ORM要求映射的主键列必须以某种方式可排序。当使用不可排序的枚举对象（如Python3）时 Enum 对象，此参数可用于设置对象的默认排序键函数。默认情况下，枚举的数据库值用作排序函数。。版本添加：：1.3.8
omit_aliases¶ -- 一个布尔值，如果为真，将从PEP 435枚举中删除别名。为了向后兼容，它默认为 False 。如果枚举具有别名并且未设置此标志，则会引发弃用警告。。。添加的版本：：1.4.5..已弃用：：1.4默认值将更改为 True 在SQLAlChemy 2.0中。
sqlalchemy.types.Enum.create(bind=None, checkfirst=False)¶inherited from the SchemaType.create() method of SchemaType
如果适用，请发出此类型的CREATE DDL。
sqlalchemy.types.Enum.drop(bind=None, checkfirst=False)¶inherited from the SchemaType.drop() method of SchemaType
如果适用，请为此类型发出DROP DDL。
表示浮点类型的类型，例如 FLOAT 或 REAL .
此类型返回python float 对象，除非 Float.asdecimal 标志设置为true，在这种情况下，它们被强制 decimal.Decimal 物体。
注解
这个 Float 类型的设计目的是从一个明确称为浮点类型的数据库类型（例如 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 Numeric type or a subclass, otherwise numeric coercion between float/Decimal 可能会或可能不会按预期工作。
类签名
sqlalchemy.types.Float.__init__(precision=None, asdecimal=False, decimal_return_scale=None)¶构造一个浮点。
precision¶ -- 用于DDL的数字精度 CREATE TABLE .
asdecimal¶ -- 与…相同的标志 Numeric ，但默认为 False . 请注意，将此标志设置为 True 导致浮点转换。
decimal_return_scale¶ -- 从浮点转换为python小数时使用的默认小数位数。由于小数点不准确，浮点值通常要长得多，而且大多数浮点数据库类型没有“小数位数”的概念，因此默认情况下，浮点类型在转换时查找前十位小数。指定此值将覆盖该长度。注意，如果没有另外指定，mysql float类型（包括“scale”）将使用“scale”作为decimal_return_scale的默认值。…版本已添加：：0.9.0
sqlalchemy.types.Float.result_processor(dialect, coltype)¶返回用于处理结果行值的转换函数。
返回一个可调用的，它将接收作为唯一位置参数的结果行列值，并返回一个值以返回给用户。
如果不需要处理，则该方法应返回 None .
一种类型 int 整数。
类签名
class sqlalchemy.types.Integer (sqlalchemy.types._LookupExpressionAdapter, sqlalchemy.types.TypeEngine)
sqlalchemy.types.Integer.get_dbapi_type(dbapi)¶从基础DB-API返回相应的类型对象（如果有）。
这对打电话很有用 setinputsizes() 例如。
sqlalchemy.types.Integer.literal_processor(dialect)¶返回一个转换函数，用于处理直接呈现而不使用绑定的文本值。
当编译器使用“文本绑定”标志时，通常在生成DDL以及后端不接受绑定参数的某些情况下使用此函数。
0.9.0 新版功能.
sqlalchemy.types.Integer.python_type¶一种类型 datetime.timedelta() 物体。
间隔类型处理 datetime.timedelta 物体。在PostgreSQL中，本地人 INTERVAL 使用类型；对于其他类型，该值存储为相对于“epoch”（1970年1月1日）的日期。
请注意 Interval 类型当前不在本机不支持间隔类型的平台上提供日期算术操作。此类操作通常需要将表达式的两边转换（例如，首先将两边转换为整数epoch值），这是当前手动过程（例如，通过 expression.func ）
类签名
class sqlalchemy.types.Interval (sqlalchemy.types.Emulated, sqlalchemy.types._AbstractInterval, sqlalchemy.types.TypeDecorator)
sqlalchemy.types.Interval.__init__(native=True, second_precision=None, day_precision=None)¶构造一个间隔对象。
sqlalchemy.types.Interval.adapt_to_emulated(impltype, **kw)¶给定一个IMPL类，将此类型与IMPL相适应，假定“已仿真”。
IMPL也应该是此类型的“模拟”版本，很可能与此类型本身是同一类。
例如：sqltypes.enum适应枚举类。
sqlalchemy.types.Interval.bind_processor(dialect)¶返回用于处理绑定值的转换函数。
返回一个callable，该callable将接收一个bind参数值作为唯一的位置参数，并返回一个要发送到db-api的值。
如果不需要处理，则该方法应返回 None .
dialect¶ -- 方言实例正在使用中。
sqlalchemy.types.Interval.impl¶alias of sqlalchemy.sql.sqltypes.DateTime
sqlalchemy.types.Interval.python_type¶sqlalchemy.types.Interval.result_processor(dialect, coltype)¶返回用于处理结果行值的转换函数。
返回一个可调用的，它将接收作为唯一位置参数的结果行列值，并返回一个值以返回给用户。
如果不需要处理，则该方法应返回 None .
用于大二进制字节数据的类型。
这个 LargeBinary 类型对应于目标平台的大型和/或未经修饰的二进制类型，例如MySQL上的blob和PostgreSQL的bytea。它还处理DBAPI的必要转换。
类签名
class sqlalchemy.types.LargeBinary (sqlalchemy.types._Binary)
sqlalchemy.types.LargeBinary.__init__(length=None)¶构造一个大二进制类型。
length¶ -- 可选，用于ddl语句中的列的长度，用于接受长度的二进制类型，例如mysql blob类型。
引用match运算符的返回类型。
作为 ColumnOperators.match() 可能是通用SQLAlchemy核心中最开放的运算符，我们不能在SQL评估时假定返回类型，因为MySQL返回的是浮点，而不是布尔值，其他后端可能会做一些不同的事情。因此，此类型充当占位符，当前是子类化 Boolean . 如果需要，类型允许方言注入结果处理功能，并且在MySQL上将返回浮点值。
1.0.0 新版功能.
类签名
用于固定精度数字的类型，例如 NUMERIC 或 DECIMAL .
此类型返回python decimal.Decimal 对象，除非 Numeric.asdecimal 标志设置为false，在这种情况下，它们被强制为python float 物体。
注解
这个 Numeric 类型的设计目的是从一个明确称为十进制类型的数据库类型（例如 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, such as FLOAT or REAL, use the Float type or a subclass, otherwise numeric coercion between float/Decimal 可能会或可能不会按预期工作。
注解
The Python decimal.Decimal class is generally slow
performing; cPython 3.3 has now switched to use the 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请注意 cdecimal 和 decimal 类库是 彼此不兼容 所以修补 cdecimal 在全局级别上，它是可以有效地与各种DBAPI一起使用的唯一方法，硬编码可以导入 decimal 类库。
类签名
class sqlalchemy.types.Numeric (sqlalchemy.types._LookupExpressionAdapter, sqlalchemy.types.TypeEngine)
sqlalchemy.types.Numeric.__init__(precision=None, scale=None, decimal_return_scale=None, asdecimal=True)¶构造一个数字。
precision¶ -- 用于DDL的数字精度 CREATE TABLE .
scale¶ -- DDL中使用的数字刻度 CREATE TABLE .
asdecimal¶ -- 默认为真。返回值是否应作为python decimal对象或float发送。不同的dbapis根据数据类型发送一个或另一个-数字类型将确保返回值在dbapis中是一致的。
decimal_return_scale¶ -- 从浮点转换为python小数时使用的默认小数位数。由于小数点不准确，浮点值通常要长得多，而且大多数浮点数据库类型都没有“小数位数”的概念，因此默认情况下，浮点类型在转换时查找前十位小数。指定此值将覆盖该长度。包含显式“.scale”值的类型，如基 Numeric 以及mysql float类型，将使用“.scale”值作为decimal_return_scale的默认值，如果没有另外指定。…添加的版本：0.9.0
当使用 Numeric 类型，应注意确保asdecimal设置适用于正在使用的dbapi-当numeric应用decimal->float或float->decimal的转换时，此转换会对收到的所有结果列产生额外的性能开销。
本地返回十进制（例如psycopg2）的dbapis在设置为 True ，因为本机十进制转换减少了浮点问题的数量，并且数字类型本身不需要应用任何进一步的转换。但是，另一个DBAPI以本机方式返回浮动 will 产生额外的转换开销，并且仍然会受到浮点数据丢失的影响-在这种情况下 asdecimal=False 将至少移除额外的转换开销。
sqlalchemy.types.Numeric.bind_processor(dialect)¶返回用于处理绑定值的转换函数。
返回一个callable，该callable将接收一个bind参数值作为唯一的位置参数，并返回一个要发送到db-api的值。
如果不需要处理，则该方法应返回 None .
dialect¶ -- 方言实例正在使用中。
sqlalchemy.types.Numeric.get_dbapi_type(dbapi)¶从基础DB-API返回相应的类型对象（如果有）。
这对打电话很有用 setinputsizes() 例如。
sqlalchemy.types.Numeric.literal_processor(dialect)¶返回一个转换函数，用于处理直接呈现而不使用绑定的文本值。
当编译器使用“文本绑定”标志时，通常在生成DDL以及后端不接受绑定参数的某些情况下使用此函数。
0.9.0 新版功能.
sqlalchemy.types.Numeric.python_type¶sqlalchemy.types.Numeric.result_processor(dialect, coltype)¶返回用于处理结果行值的转换函数。
返回一个可调用的，它将接收作为唯一位置参数的结果行列值，并返回一个值以返回给用户。
如果不需要处理，则该方法应返回 None .
保存使用pickle序列化的python对象。
pickleType建立在二进制类型的基础上，以应用python的 pickle.dumps() 到传入对象，以及 pickle.loads() 在退出时，允许将任何可pickle python对象存储为序列化二进制字段。
允许为与关联的元素传播ORM更改事件 PickleType 见 突变跟踪 .
sqlalchemy.types.PickleType.__init__(protocol=4, pickler=None, comparator=None, impl=None)¶构造pickleType。
protocol¶ -- 默认为 pickle.HIGHEST_PROTOCOL .
pickler¶ -- 如果cpickle不可用，则默认为cpickle.pickle或pickle.pickle。可能是与pickle兼容的任何对象 dumps 和 loads 方法。
comparator¶ -- 用于比较此类型值的2参数可调用谓词。如果留下 None ，python“equals”运算符用于比较值。
impl¶ -- 一种二进制存储器 TypeEngine 类或实例来代替默认的 LargeBinary 。例如：CLASS： _mysql.LONGBLOB 类在使用MySQL时可能更有效。。。添加的版本：：1.4.20
sqlalchemy.types.PickleType.bind_processor(dialect)¶为给定的提供绑定值处理函数 Dialect .
这是实现 TypeEngine 约束值转换合同。 TypeDecorator 将包装用户定义的 process_bind_param() 在这里。
用户定义的代码可以直接重写这个方法，尽管它可能最适合使用 process_bind_param() 以便处理所提供的 self.impl 保持。
dialect¶ -- 方言实例正在使用中。
此方法与 result_processor() 此类的方法。
sqlalchemy.types.PickleType.compare_values(x, y)¶给定两个值，比较它们是否相等。
默认情况下，此调用 TypeEngine.compare_values() 在底层“impl”中，通常使用python equals运算符 == .
ORM使用此函数将原始加载值与截取的“已更改”值进行比较，以确定是否发生了净更改。
sqlalchemy.types.PickleType.impl¶alias of sqlalchemy.sql.sqltypes.LargeBinary
sqlalchemy.types.PickleType.result_processor(dialect, coltype)¶为给定的提供结果值处理函数 Dialect .
这是实现 TypeEngine 结果值转换合同。 TypeDecorator 将包装用户定义的 process_result_value() 在这里。
用户定义的代码可以直接重写这个方法，尽管它可能最适合使用 process_result_value() 以便处理所提供的 self.impl 保持。
此方法与 bind_processor() 此类的方法。
将类型标记为可能需要架构级DDL才能使用。
支持必须显式创建/删除的类型（即pg枚举类型）以及由表或架构级别约束、触发器和其他规则补充的类型。
SchemaType 类也可以作为 DDLEvents.before_parent_attach() 和 DDLEvents.after_parent_attach() 事件，其中事件围绕类型对象与父对象的关联触发。 Column .
类签名
class sqlalchemy.types.SchemaType (sqlalchemy.sql.expression.SchemaEventTarget)
sqlalchemy.types.SchemaType.adapt(impltype, **kw)¶sqlalchemy.types.SchemaType.bind¶sqlalchemy.types.SchemaType.copy(**kw)¶sqlalchemy.types.SchemaType.create(bind=None, checkfirst=False)¶如果适用，请发出此类型的CREATE DDL。
sqlalchemy.types.SchemaType.drop(bind=None, checkfirst=False)¶如果适用，请为此类型发出DROP DDL。
较小的一种 int 整数。
通常会生成 SMALLINT 在DDL中，否则行为就像正常的 Integer 在 Python 这边。
所有字符串和字符类型的基。
在SQL中，对应于varchar。也可以采用python unicode对象，并使用bind参数（与结果集相反）对数据库的编码进行编码。
这个 length 当 String 类型在CREATETABLE语句中使用，因为varchar在大多数数据库中都需要一个长度。
sqlalchemy.types.String.RETURNS_BYTES = symbol('RETURNS_BYTES')¶sqlalchemy.types.String.RETURNS_CONDITIONAL = symbol('RETURNS_CONDITIONAL')¶sqlalchemy.types.String.RETURNS_UNICODE = symbol('RETURNS_UNICODE')¶sqlalchemy.types.String.RETURNS_UNKNOWN = symbol('RETURNS_UNKNOWN')¶sqlalchemy.types.String.__init__(length=None, collation=None, convert_unicode=False, unicode_error=None, _warn_on_bytestring=False, _expect_unicode=False)¶创建字符串保持类型。
length¶ -- 可选，用于DDL和CAST表达式的列的长度。如果没有，可以安全地省略 CREATE TABLE 将发布。某些数据库可能需要 length 在DDL中使用，并在 CREATE TABLE 如果 VARCHAR 不包括长度。该值是否解释为字节或字符是特定于数据库的。
collation¶ -- 可选，在DDL和CAST表达式中使用的列级排序规则。使用SQLite、MySQL和PostgreSQL支持的COLLATE关键字呈现。E、 g.：>>>从sqlalchemy import cast，select，String>>>打印（select（cast（'some String'，String（collation='utf8'）））select cast（：param_1 AS VARCHAR COLLATE utf8）AS anon_
convert_unicode¶ -- 当设置为 True , the String 类型将假定输入将作为python 2下的python unicode对象传递，结果将作为python unicode对象返回。在DBAPI在python 2下不支持pythonUnicode的罕见情况下，sqlachemy将在字符串上使用自己的编码器/解码器功能，参考 create_engine.encoding 参数参数传递给 create_engine() 作为编码。…已弃用：：1.3 String.convert_unicode 参数已弃用，将在将来的版本中删除。所有现代DBAPI现在都直接支持PythonUnicode，而这个参数是不必要的。对于极为罕见的情况，python unicode将由sqlachemy在后端进行编码/解码， does 本机支持python unicode，字符串值 "force" 可以在此处传递，这将导致无条件使用SQLAlchemy的编码/解码服务。…注意：：sqlacalchemy的unicode转换标志和特性只适用于python 2；在python 3中，所有字符串对象都是unicode对象。出于这个原因，以及事实上，几乎所有现代DBAPI现在都支持Unicode，即使在Python2下， String.convert_unicode 标志本身就是一个遗留功能。…注：在绝大多数情况下， Unicode 或 UnicodeText 数据类型应用于 Column 它期望存储非ascii数据。这些数据类型将确保在数据库端使用正确的类型，并在Python2下设置正确的Unicode行为。。另请参见： create_engine.convert_unicode - Engine 宽参数
unicode_error¶ -- 可选，用于处理Unicode转换错误的方法。表现得像 errors 标准库的关键字参数 string.decode() 函数，要求 String.convert_unicode 设置为 "force" …已弃用：：1.3 String.unicode_errors 参数已弃用，将在将来的版本中删除。这个参数对于现代的python dbapis来说是不必要的，并且会显著降低性能。
sqlalchemy.types.String.bind_processor(dialect)¶返回用于处理绑定值的转换函数。
返回一个callable，该callable将接收一个bind参数值作为唯一的位置参数，并返回一个要发送到db-api的值。
如果不需要处理，则该方法应返回 None .
dialect¶ -- 方言实例正在使用中。
sqlalchemy.types.String.get_dbapi_type(dbapi)¶从基础DB-API返回相应的类型对象（如果有）。
这对打电话很有用 setinputsizes() 例如。
sqlalchemy.types.String.literal_processor(dialect)¶返回一个转换函数，用于处理直接呈现而不使用绑定的文本值。
当编译器使用“文本绑定”标志时，通常在生成DDL以及后端不接受绑定参数的某些情况下使用此函数。
0.9.0 新版功能.
sqlalchemy.types.String.python_type¶sqlalchemy.types.String.result_processor(dialect, coltype)¶返回用于处理结果行值的转换函数。
返回一个可调用的，它将接收作为唯一位置参数的结果行列值，并返回一个值以返回给用户。
如果不需要处理，则该方法应返回 None .
大小可变的字符串类型。
在SQL中，通常对应于CLOB或文本。也可以采用python unicode对象并用bind参数（与结果集相反）编码到数据库的编码。通常，文本对象没有长度；虽然某些数据库在此处接受长度参数，但其他数据库将拒绝该参数。
类签名
一种类型 datetime.time() 物体。
类签名
class sqlalchemy.types.Time (sqlalchemy.types._LookupExpressionAdapter, sqlalchemy.types.TypeEngine)
sqlalchemy.types.Time.get_dbapi_type(dbapi)¶从基础DB-API返回相应的类型对象（如果有）。
这对打电话很有用 setinputsizes() 例如。
sqlalchemy.types.Time.python_type¶长度可变的Unicode字符串类型。
这个 Unicode 类型为 String 假定可能包含非ASCII字符的输入和输出字符串的子类，对于某些后端，它暗示显式支持非ASCII数据的基础列类型，例如 NVARCHAR 在Oracle和SQL Server上。这将影响……的产量 CREATE TABLE 语句和 CAST 函数，而且在某些情况下，DBAPI本身在处理绑定参数的方式上也会指示不同的行为。
对象使用的字符编码。 Unicode 用于向数据库发送和接收数据的类型通常由DBAPI本身决定。所有现代DBAPI都支持非ASCII字符串，但可能有不同的管理数据库编码的方法；如有必要，应按照中有关目标DBAPI的说明中的详细说明配置此编码 方言 部分。
在现代SQL炼金术中，使用 Unicode DataType通常不暗示SQLAlChemy本身内的任何编码/解码行为。在历史上，当DBAPI不支持Python时 unicode Python2下的对象，SQLAlChemy本身处理Unicode编码/解码服务，这些服务将由标志控制 String.convert_unicode ；此标志已弃用，因为Python 3不再需要此标志。
使用Python 2时，传递到使用 Unicode 数据类型必须为 unicode ，而不是 str 在Python2中，它相当于 bytes 。在Python3中，传递到使用 Unicode 数据类型应为 str 。看到那面旗帜了吗？ String.convert_unicode 有关Python2下Unicode编码/解码行为的更多讨论。
警告
已知一些数据库后端(特别是具有pyodbc的SQL Server)对记录为 NVARCHAR 键入，而不是 VARCHAR ，包括数据类型不匹配错误和未使用索引。请参阅上的一节 DialectEvents.do_setinputsizes() 有关为后端(如带有pyodbc的SQL Server以及CX_ORACLE)解决Unicode字符问题的背景信息。
类签名
sqlalchemy.types.Unicode.__init__(length=None, **kwargs)¶创建一个 Unicode 对象。
参数与 String ，除了 convert_unicode 默认为 True .
无限长的Unicode字符串类型。
见 Unicode 有关此对象的Unicode行为的详细信息。
喜欢 Unicode 使用 UnicodeText 类型表示后端使用的支持Unicode的类型，例如 NCLOB ， NTEXT .
类签名
sqlalchemy.types.UnicodeText.__init__(length=None, **kwargs)¶创建一个Unicode转换文本类型。
参数与 TextClause ，除了 convert_unicode 默认为 True .
此类类型指的是属于SQL标准的一部分或可能在数据库后端子集中找到的类型。与“一般”类型不同，SQL标准/多供应商类型具有 no 保证在所有后端上工作，并且只在那些以名称显式支持它们的后端上工作。也就是说，类型将始终在DDL中发出其确切名称 CREATE TABLE 发行。
| Object Name | Description |
|---|---|
表示SQL数组类型。 |
|
SQL bigint类型。 |
|
SQL二进制类型。 |
|
SQL blob类型。 |
|
SQL布尔类型。 |
|
SQL字符类型。 |
|
Culb型。 |
|
SQL日期类型。 |
|
SQL日期时间类型。 |
|
SQL十进制类型。 |
|
SQL浮点类型。 |
|
alias of |
|
SQL int或integer类型。 |
|
表示SQL JSON类型。 |
|
SQL NChar类型。 |
|
SQL数值类型。 |
|
SQL nvarchar类型。 |
|
SQL实数类型。 |
|
SQL smallint类型。 |
|
SQL文本类型。 |
|
SQL时间类型。 |
|
SQL时间戳类型。 |
|
sql varbinary类型。 |
|
SQL varchar类型。 |
表示SQL数组类型。
注解
此类型是所有数组操作的基础。不过，目前 只有PostgreSQL后端支持SQLAlChemy中的SQL数组 。建议使用特定于PostgreSQL的 sqlalchemy.dialects.postgresql.ARRAY 在PostgreSQL中使用数组类型时直接输入，因为它提供了特定于该后端的附加运算符。
ARRAY 是支持各种SQL标准函数（如 array_agg 它显式地涉及数组；但是，除了PostgreSQL后端和一些可能的第三方方言之外，没有其他的SQLAlchemy内置方言支持这种类型。
安 ARRAY 类型是根据元素的“类型”构造的：
mytable = Table("mytable", metadata,
Column("data", ARRAY(Integer))
)上面的类型表示一个n维数组，这意味着支持后端（如PostgreSQL）将自动解释具有任意维数的值。要生成以一维整数数组形式传递的插入构造，请执行以下操作：
connection.execute(
mytable.insert(),
data=[1,2,3]
)这个 ARRAY 如果给定固定的维度数，则可以构造类型：
mytable = Table("mytable", metadata,
Column("data", ARRAY(Integer, dimensions=2))
)发送多个维度是可选的，但如果数据类型要表示多个维度的数组，则建议这样做。此号码用于：
将类型声明本身发送到数据库时，例如 INTEGER[][]
将python值转换为数据库值时，反之亦然，例如 Unicode 对象使用此数字有效地访问数组结构内部的字符串值，而不需要进行每行类型检查。
与python一起使用时 getitem 访问器，维度数用于定义 [] 运算符应返回，例如对于二维整数数组：
>>> expr = table.c.column[5] # returns ARRAY(Integer, dimensions=1)
>>> expr = expr[6] # returns Integer对于一维数组， ARRAY 没有维度参数的实例通常会采用一维行为。
类型的SQL表达式 ARRAY 支持“索引”和“切片”行为。 Python [] 在给定整数索引或片的情况下，运算符在这里正常工作。数组默认为基于1的索引。运算符生成二进制表达式构造，这将为select语句生成适当的SQL:：
select(mytable.c.data[5], mytable.c.data[2:7])以及当 Update.values() 使用方法：
mytable.update().values({
mytable.c.data[5]: 7,
mytable.c.data[2:7]: [1, 2, 3]
})这个 ARRAY 类型还为运算符提供 Comparator.any() 和 Comparator.all() . PostgreSQL特定版本 ARRAY 还提供了其他运算符。
1.1.0 新版功能.
类签名
class sqlalchemy.types.ARRAY (sqlalchemy.sql.expression.SchemaEventTarget, sqlalchemy.types.Indexable, sqlalchemy.types.Concatenable, sqlalchemy.types.TypeEngine)
为定义比较操作 ARRAY .
在这种类型的方言特定形式上有更多的运算符可用。见 Comparator .
类签名
class sqlalchemy.types.ARRAY.Comparator (sqlalchemy.types.Comparator, sqlalchemy.types.Comparator)
sqlalchemy.types.ARRAY.Comparator.all(other, operator=None)¶返回 other operator ALL (array) 条款。
注解
此方法是一个 ARRAY -特定的构造，现在由 any_() 函数，该函数具有不同的调用风格。这个 any_() 函数也在方法级别通过 ColumnOperators.any_() 方法。
特定于阵列的用法 Comparator.all() 详情如下：
from sqlalchemy.sql import operators
conn.execute(
select(table.c.data).where(
table.c.data.all(7, operator=operators.lt)
)
)sqlalchemy.types.ARRAY.Comparator.any(other, operator=None)¶返回 other operator ANY (array) 条款。
注解
此方法是一个 ARRAY -特定的构造，现在由 any_() 函数，该函数具有不同的调用风格。这个 any_() 函数也在方法级别通过 ColumnOperators.any_() 方法。
特定于阵列的用法 Comparator.any() 详情如下：
from sqlalchemy.sql import operators
conn.execute(
select(table.c.data).where(
table.c.data.any(7, operator=operators.lt)
)
)sqlalchemy.types.ARRAY.Comparator.contains(*arg, **kw)¶实现“contains”运算符。
生成一个类似表达式，该表达式根据字符串值中间的匹配项进行测试：
column LIKE '%' || <other> || '%'例如。：：
stmt = select(sometable).\
where(sometable.c.column.contains("foobar"))因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值， ColumnOperators.contains.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符，以便它们与自身匹配，而不是作为通配符匹配。或者， ColumnOperators.contains.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是文本字符串时可以使用该字符。
other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.contains.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.包含（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param |‘%‘ESCAPE’/”，值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.contains（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.contains.autoescape ：：someColumn.contains（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。
sqlalchemy.types.ARRAY.__init__(item_type, as_tuple=False, dimensions=None, zero_indexes=False)¶构建一个 ARRAY .
例如。：：
Column('myarray', ARRAY(Integer))论点是：
item_type¶ -- 此数组项的数据类型。注意维数在这里是不相关的，所以多维数组 INTEGER[][] ，构造为 ARRAY(Integer) ，而不是 ARRAY(ARRAY(Integer)) 或者这样。
as_tuple=False¶ -- 指定是否应将返回结果从列表转换为元组。通常不需要这个参数，因为python列表与SQL数组很好地对应。
dimensions¶ -- 如果非“无”，则数组将采用固定数量的维度。这会影响数组在数据库中的声明方式、它如何解释python和结果值，以及表达式行为如何与“getitem”运算符一起工作。请参阅中的说明 ARRAY 更多细节。
zero_indexes=False¶ -- 如果为true，则索引值将在基于python零的索引和基于sql one的索引之间转换，例如，在传递到数据库之前，将向所有索引值添加一个值。
sqlalchemy.types.ARRAY.comparator_factory¶sqlalchemy.types.ARRAY.compare_values(x, y)¶比较两个值是否相等。
sqlalchemy.types.ARRAY.hashable¶如果标志为false，则表示此类型的值不可哈希。
由ORM在唯一结果列表时使用。
sqlalchemy.types.ARRAY.python_type¶sqlalchemy.types.ARRAY.zero_indexes = False¶如果Python的索引是基于1的，那么Python的索引应该解释为True。
SQL bigint类型。
类签名
SQL二进制类型。
类签名
class sqlalchemy.types.BINARY (sqlalchemy.types._Binary)
SQL blob类型。
类签名
SQL布尔类型。
类签名
SQL字符类型。
类签名
Culb型。
这种类型可以在Oracle和Informix中找到。
类签名
SQL日期类型。
类签名
SQL日期时间类型。
类签名
SQL十进制类型。
类签名
SQL浮点类型。
类签名
sqlalchemy.types..sqlalchemy.types.INT¶alias of sqlalchemy.sql.sqltypes.INTEGER
表示SQL JSON类型。
注解
JSON 作为供应商特定JSON类型的外观提供。由于它支持JSON SQL操作，因此它只在具有实际JSON类型的后端上工作，目前：
PostgreSQL-请参阅 sqlalchemy.dialects.postgresql.JSON 和 sqlalchemy.dialects.postgresql.JSONB 对于后端特定的注释
MySQL-请参阅 sqlalchemy.dialects.mysql.JSON 对于后端特定的注释
从版本3.9开始的SQLite-请参见 sqlalchemy.dialects.sqlite.JSON 对于后端特定的注释
Microsoft SQL Server 2016及更高版本-请参阅 sqlalchemy.dialects.mssql.JSON 对于后端特定的注释
JSON 是支持本地JSON数据类型日益流行的核心的一部分。
这个 JSON 类型存储任意JSON格式的数据，例如：
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
这个 JSON 数据类型提供以下附加的SQL操作：
键控索引操作：
data_table.c.data['some key']整数索引操作：
data_table.c.data[3]路径索引操作：
data_table.c.data[('key_1', 'key_2', 5, ..., 'key_n')]特定JSON元素类型的数据转换器，在调用索引或路径操作之后：：
data_table.c.data["some key"].as_integer()1.3.11 新版功能.
其他操作可能来自的方言特定版本 JSON ，例如 sqlalchemy.dialects.postgresql.JSON 和 sqlalchemy.dialects.postgresql.JSONB 它们都提供了附加的特定于PostgreSQL的操作。
将JSON元素转换为其他类型
索引操作，即通过使用Python括号运算符调用表达式调用的操作，如 some_column['some key'] ，返回类型默认为的表达式对象 JSON 默认情况下，这样可以对结果类型调用进一步的面向JSON的指令。但是，更常见的情况可能是索引操作返回特定的标量元素，例如字符串或整数。为了以后端不可知的方式提供对这些元素的访问，提供了一系列数据转换器：
Comparator.as_string() -以字符串形式返回元素
Comparator.as_boolean() -以布尔值形式返回元素
Comparator.as_float() -将元素作为浮点返回
Comparator.as_integer() -以整数形式返回元素
这些数据转换器通过支持方言来实现，以确保与上述类型的比较按预期工作，例如：
# integer comparison
data_table.c.data["some_integer_key"].as_integer() == 5
# boolean comparison
data_table.c.data["some_boolean"].as_boolean() == True1.3.11 新版功能: 为基本JSON数据元素类型添加了特定于类型的caster。
注解
data caster函数是版本1.3.11中的新功能，它取代了以前记录的使用CAST的方法；作为参考，它如下所示：
from sqlalchemy import cast, type_coerce
from sqlalchemy import String, JSON
cast(
data_table.c.data['some_key'], String
) == type_coerce(55, JSON)上述情况现在直接起作用：
data_table.c.data['some_key'].as_integer() == 5有关1.3.x系列中以前的比较方法的详细信息，请参阅SQLAlchemy 1.2的文档或该版本发行版的doc/目录中包含的HTML文件。
使用ORM时检测JSON列中的更改
这个 JSON 当与sqlAlchemy ORM一起使用时，类型不会检测到结构的就地突变。为了检测到这些， sqlalchemy.ext.mutable 必须使用扩展名。此扩展将允许对数据结构进行“就地”更改，以生成工作单元将检测到的事件。参见中的示例 HSTORE 一个简单的涉及字典的例子。
支持JSON null与SQL null
使用空值时， JSON 类型建议使用两个特定的常量，以便区分计算结果为SQL NULL的列（例如无值）与 "null" . 若要根据SQL为空的值插入或选择，请使用常量 null() ：：
from sqlalchemy import null
conn.execute(table.insert(), json_value=null())根据JSON值插入或选择 "null" ，使用常量 JSON.NULL ：：
conn.execute(table.insert(), json_value=JSON.NULL)这个 JSON 类型支持标志 JSON.none_as_null 当设置为true时，将导致python常量 None 计算为sql null的值，如果设置为false，则会导致python常量 None 评估JSON的值 "null" . python值 None 可与以下两者结合使用： JSON.NULL 和 null() 为了指示空值，但必须注意 JSON.none_as_null 在这些情况下。
自定义JSON序列化程序
使用的JSON序列化程序和反序列化程序 JSON 默认为Python的 json.dumps 和 json.loads 函数；对于psycopg2方言，psycopg2可能正在使用它自己的自定义加载程序函数。
为了影响序列化程序/反序列化程序，它们当前可在 create_engine() 通过 create_engine.json_serializer 和 create_engine.json_deserializer 参数。例如，关闭 ensure_ascii ：：
engine = create_engine(
"sqlite://",
json_serializer=lambda obj: json.dumps(obj, ensure_ascii=False))在 1.3.7 版更改: SQLite方言 json_serializer 和 json_deserializer 参数重命名自 _json_serializer 和 _json_deserializer .
参见
sqlalchemy.dialects.postgresql.JSON
sqlalchemy.dialects.postgresql.JSONB
1.1 新版功能.
为定义比较操作 JSON .
类签名
class sqlalchemy.types.JSON.Comparator (sqlalchemy.types.Comparator, sqlalchemy.types.Comparator)
sqlalchemy.types.JSON.Comparator.as_boolean()¶将索引值转换为布尔值。
例如。：：
stmt = select(
mytable.c.json_column['some_data'].as_boolean()
).where(
mytable.c.json_column['some_data'].as_boolean() == True
)1.3.11 新版功能.
sqlalchemy.types.JSON.Comparator.as_float()¶将索引值转换为浮点值。
例如。：：
stmt = select(
mytable.c.json_column['some_data'].as_float()
).where(
mytable.c.json_column['some_data'].as_float() == 29.75
)1.3.11 新版功能.
sqlalchemy.types.JSON.Comparator.as_integer()¶将索引值转换为整数。
例如。：：
stmt = select(
mytable.c.json_column['some_data'].as_integer()
).where(
mytable.c.json_column['some_data'].as_integer() == 5
)1.3.11 新版功能.
sqlalchemy.types.JSON.Comparator.as_json()¶将索引值转换为JSON。
例如。：：
stmt = select(mytable.c.json_column['some_data'].as_json())这通常是索引元素在任何情况下的默认行为。
请注意，并非所有后端都支持完整JSON结构的比较。
1.3.11 新版功能.
sqlalchemy.types.JSON.Comparator.as_numeric(precision, scale, asdecimal=True)¶将索引值转换为数字/小数。
例如。：：
stmt = select(
mytable.c.json_column['some_data'].as_numeric(10, 6)
).where(
mytable.c.
json_column['some_data'].as_numeric(10, 6) == 29.75
)1.4.0b2 新版功能.
sqlalchemy.types.JSON.Comparator.as_string()¶将索引值转换为字符串。
例如。：：
stmt = select(
mytable.c.json_column['some_data'].as_string()
).where(
mytable.c.json_column['some_data'].as_string() ==
'some string'
)1.3.11 新版功能.
JSON表达式中index/path元素的公共函数。
sqlalchemy.types.JSON.JSONElementType.bind_processor(dialect)¶返回用于处理绑定值的转换函数。
返回一个callable，该callable将接收一个bind参数值作为唯一的位置参数，并返回一个要发送到db-api的值。
如果不需要处理，则该方法应返回 None .
dialect¶ -- 方言实例正在使用中。
sqlalchemy.types.JSON.JSONElementType.literal_processor(dialect)¶返回一个转换函数，用于处理直接呈现而不使用绑定的文本值。
当编译器使用“文本绑定”标志时，通常在生成DDL以及后端不接受绑定参数的某些情况下使用此函数。
0.9.0 新版功能.
JSON索引值的数据类型的占位符。
这允许执行时处理特殊语法的JSON索引值。
类签名
class sqlalchemy.types.JSON.JSONIndexType (sqlalchemy.types.JSONElementType)
JSON索引值的数据类型的占位符。
这允许执行时处理特殊语法的JSON索引值。
类签名
class sqlalchemy.types.JSON.JSONIntIndexType (sqlalchemy.types.JSONIndexType)
JSON路径操作的占位符类型。
这允许将基于路径的索引值执行时处理为特定的SQL语法。
类签名
class sqlalchemy.types.JSON.JSONPathType (sqlalchemy.types.JSONElementType)
JSON索引值的数据类型的占位符。
这允许执行时处理特殊语法的JSON索引值。
类签名
class sqlalchemy.types.JSON.JSONStrIndexType (sqlalchemy.types.JSONIndexType)
sqlalchemy.types.JSON.NULL = symbol('JSON_NULL')¶描述空的JSON值。
此值用于强制 "null" 用作值。python的值 None 将被识别为SQL空值或JSON "null" ，基于 JSON.none_as_null 旗帜； JSON.NULL 常量可用于始终解析为JSON "null" 无论此设置如何。这与 null() 构造，它始终解析为SQL空值。例如。：：
from sqlalchemy import null
from sqlalchemy.dialects.postgresql import JSON
# will *always* insert SQL NULL
obj1 = MyObject(json_value=null())
# will *always* insert JSON string "null"
obj2 = MyObject(json_value=JSON.NULL)
session.add_all([obj1, obj2])
session.commit()为了将JSON NULL设置为列的默认值，最透明的方法是使用 text() ：：
Table(
'my_table', metadata,
Column('json_data', JSON, default=text("'null'"))
)虽然可以使用 JSON.NULL 在这种情况下， JSON.NULL 值将作为列的值返回，在ORM上下文中或默认值的其他重新调整用途中，这可能是不可取的。使用SQL表达式意味着将在检索生成的默认值的上下文中从数据库中重新提取该值。
sqlalchemy.types.JSON.__init__(none_as_null=False)¶构建一个 JSON 类型。
none_as_null=False¶ -- 如果为True，则持久值 None 作为SQL null值，而不是 null 。请注意，当此标志为false时， null() 构造仍然可以用于持久化NULL值：：FROM sqlalChemy import null connec.ecute(table.insert()，data=null())..注：： JSON.none_as_null 会吗？ not 应用于传递给的值 Column.default 和 Column.server_default ；价值为 None 为这些参数传递表示“没有默认存在”。此外，在SQL比较表达式中使用Python值时， None 继续引用SQL NULL，而不是JSON NULL。这个 JSON.none_as_null 标志显式引用 持之以恒 INSERT或UPDATE语句中的值的。这个 JSON.NULL 值应用于希望与JSON NULL进行比较的SQL表达式。。。另请参阅：： JSON.NULL
sqlalchemy.types.JSON.bind_processor(dialect)¶返回用于处理绑定值的转换函数。
返回一个callable，该callable将接收一个bind参数值作为唯一的位置参数，并返回一个要发送到db-api的值。
如果不需要处理，则该方法应返回 None .
dialect¶ -- 方言实例正在使用中。
sqlalchemy.types.JSON.comparator_factory¶sqlalchemy.types.JSON.python_type¶sqlalchemy.types.JSON.result_processor(dialect, coltype)¶返回用于处理结果行值的转换函数。
返回一个可调用的，它将接收作为唯一位置参数的结果行列值，并返回一个值以返回给用户。
如果不需要处理，则该方法应返回 None .
sqlalchemy.types.JSON.should_evaluate_none¶如果为True，则为Python常量 None 被认为是由此类型显式处理的。
ORM使用此标志指示 None 在INSERT语句中传递给列，而不是从INSERT语句中省略该列，这具有激发列级默认值的效果。它还允许对Python None有特殊行为的类型(如JSON类型)表明它们希望显式处理None值。
若要在现有类型上设置此标志，请使用 TypeEngine.evaluates_none() 方法。
1.1 新版功能.
SQL int或integer类型。
类签名
SQL NChar类型。
类签名
SQL nvarchar类型。
类签名
SQL数值类型。
类签名
SQL实数类型。
类签名
SQL smallint类型。
SQL文本类型。
类签名
SQL时间类型。
类签名
SQL时间戳类型。
TIMESTAMP 数据类型在某些后端（如PostgreSQL和Oracle）支持时区存储。使用 TIMESTAMP.timezone 参数，以便为这些后端启用“timestamp with timezone”。
类签名
class sqlalchemy.types.TIMESTAMP (sqlalchemy.types.DateTime)
sqlalchemy.types.TIMESTAMP.__init__(timezone=False)¶构建新的 TIMESTAMP .
timezone¶ -- 布尔函数。指示时间戳类型应启用时区支持（如果目标数据库上可用）。在每种方言的基础上，类似于“Timestamp with Timezone”。如果目标数据库不支持时区，则忽略此标志。
sqlalchemy.types.TIMESTAMP.get_dbapi_type(dbapi)¶从基础DB-API返回相应的类型对象（如果有）。
这对打电话很有用 setinputsizes() 例如。
sql varbinary类型。
类签名
class sqlalchemy.types.VARBINARY (sqlalchemy.types._Binary)
SQL varchar类型。
类签名
还可以从每个数据库的方言模块中导入特定于数据库的类型。见 方言 对您感兴趣的数据库的引用。
例如，mysql有一个 BIGINT 类型和PostgreSQL具有 INET 类型。要使用这些，请从模块中显式导入它们：
from sqlalchemy.dialects import mysql
table = Table('foo', metadata,
Column('id', mysql.BIGINT),
Column('enumerates', mysql.ENUM('a', 'b', 'c'))
)或某些PostgreSQL类型：
from sqlalchemy.dialects import postgresql
table = Table('foo', metadata,
Column('ipaddress', postgresql.INET),
Column('elements', postgresql.ARRAY(String))
)每个方言在其内部提供该后端支持的完整类型名集 __all__ 集合，使 import * 或类似操作将导入为该后端实现的所有支持类型：
from sqlalchemy.dialects.postgresql import *
t = Table('mytable', metadata,
Column('id', INTEGER, primary_key=True),
Column('name', VARCHAR(300)),
Column('inetaddr', INET)
)其中，integer和varchar类型最终来自sqlacalchemy.types，inet特定于PostgreSQL方言。
某些方言级别类型与SQL标准类型具有相同的名称，但也提供了其他参数。例如，MySQL实现了完整的字符和字符串类型，包括其他参数，例如 collation 和 charset ：：
from sqlalchemy.dialects.mysql import VARCHAR, TEXT
table = Table('foo', meta,
Column('col1', VARCHAR(200, collation='binary')),
Column('col2', TEXT(charset='latin1'))
)flambé! the dragon and The Alchemist image designs created and generously donated by Rotem Yaari.
Created using Sphinx 4.2.0.