SqlAlchemy 2.0 中文文档（四十一）（2）https://developer.aliyun.com/article/1563081
“大写字母”数据类型
与“驼峰命名法”类型相反的是“大写字母”数据类型。这些数据类型总是从特定的“驼峰命名法”数据类型继承，并且始终表示确切的数据类型。当使用“大写字母”数据类型时，类型的名称始终精确地呈现，而不考虑当前后端是否支持它。因此，在 SQLAlchemy 应用程序中使用“大写字母”类型表示需要特定数据类型，这随后意味着应用程序通常（如果没有采取额外步骤）会受限于那些完全使用给定类型的后端。大写字母类型的示例包括VARCHAR、NUMERIC、INTEGER和TIMESTAMP，它们直接继承自前面提到的“驼峰命名法”类型String、Numeric、Integer和DateTime。
作为sqlalchemy.types的一部分的“大写字母”数据类型是通用 SQL 类型，通常期望在至少两个后端上可用。
通用“大写字母”数据类型的参考资料请参见 SQL 标准和多供应商“大写字母”类型。
后端特定的“大写字母”数据类型
大多数数据库还具有完全特定于这些数据库的数据类型，或者添加了特定于这些数据库的附加参数。对于这些数据类型，特定的 SQLAlchemy 方言提供了后端特定的“大写”数据类型，用于在其他后端上没有类似物的 SQL 类型。后端特定大写数据类型的示例包括 PostgreSQL 的JSONB、SQL Server 的IMAGE和 MySQL 的TINYTEXT。
某些后端还可能包括“大写”数据类型，这些数据类型扩展了来自sqlalchemy.types模块中相同“大写”数据类型的参数。例如，当创建 MySQL 字符串数据类型时，可能希望指定 MySQL 特定参数，如charset或national，这些参数可以从 MySQL 版本的VARCHAR作为仅 MySQL 参数VARCHAR.charset和VARCHAR.national。
后端特定类型的 API 文档在方言特定文档中列出，详见方言。## 使用“大写”和后端特定类型用于多个后端
检查“大写”和“驼峰”类型的存在自然会引出如何在使用特定后端时利用“大写”数据类型的自然用例，但仅当该后端正在使用时。为了将数据库无关的“驼峰”和特定后端的“大写”系统联系在一起，可以使用TypeEngine.with_variant()方法将类型组合在一起，以在特定后端上使用特定行为。
例如，要使用String数据类型，但在运行时在 MySQL 上使用VARCHAR.charset参数的VARCHAR创建表时，可以使用TypeEngine.with_variant()如下所示：
from sqlalchemy import MetaData from sqlalchemy import Table, Column, Integer, String from sqlalchemy.dialects.mysql import VARCHAR metadata_obj = MetaData() user = Table( "user", metadata_obj, Column("user_name", String(100), primary_key=True), Column( "bio", String(255).with_variant(VARCHAR(255, charset="utf8"), "mysql", "mariadb"), ), )
在上面的表定义中，"bio"列将在所有后端上具有字符串行为。在大多数后端上，它将在 DDL 中呈现为VARCHAR。然而，在 MySQL 和 MariaDB（通过以mysql或mariadb开头的数据库 URL 表示）上，它将呈现为VARCHAR(255) CHARACTER SET utf8。
另请参阅
TypeEngine.with_variant() - 附加用法示例和注意事项 ## 通用“驼峰大小写”类型
通用类型指定一个列，该列可以读取、写入和存储特定类型的 Python 数据。当发出CREATE TABLE语句时，SQLAlchemy 将选择目标数据库上可用的最佳数据库列类型。对于完全控制在CREATE TABLE中发出的列类型，比如VARCHAR，请参见 SQL 标准和多个供应商的“大写”类型和本章的其他部分。
| 对象名称 | 描述 |
| BigInteger | 用于较大的int整数的类型。 |
| Boolean | 一个布尔数据类型。 |
| Date | 用于datetime.date()对象的类型。 |
| DateTime | 用于datetime.datetime()对象的类型。 |
| Double | 用于双精度FLOAT浮点类型的类型。 |
| Enum | 通用枚举类型。 |
| Float | 代表浮点类型，如FLOAT或REAL的类型。 |
| Integer | 一个int整数的类型。 |
| Interval | 用于datetime.timedelta()对象的类型。 |
| LargeBinary | 用于大型二进制字节数据的类型。 |
| MatchType | 指代 MATCH 运算符的返回类型。 |
| Numeric | 非整数数字类型的基类，如NUMERIC、FLOAT、DECIMAL和其他变体。 |
| PickleType | 包含使用 pickle 序列化的 Python 对象。 |
| SchemaType | 添加了允许将模式级 DDL 与类型关联的类型的功能。 |
| SmallInteger | 用于较小的int整数的类型。 |
| String | 所有字符串和字符类型的基类。 |
| Text | 可变大小的字符串类型。 |
| Time | 用于datetime.time()对象的类型。 |
| Unicode | 一个可变长度的 Unicode 字符串类型。 |
| UnicodeText | 一个无限长度的 Unicode 字符串类型。 |
| Uuid | 表示与数据库无关的 UUID 数据类型。 |
class sqlalchemy.types.BigInteger
用于较大的int整数的类型。
在 DDL 中通常生成 BIGINT，在 Python 端则像正常的 Integer 一样操作。
类签名
class sqlalchemy.types.BigInteger (sqlalchemy.types.Integer)
class sqlalchemy.types.Boolean
布尔数据类型。
Boolean 通常在 DDL 方面使用 BOOLEAN 或 SMALLINT，在 Python 方面处理 True 或 False。
Boolean 数据类型目前有两个断言级别，用于确保持久化的值是简单的 true/false 值。对于所有后端，仅接受 Python 值 None、True、False、1 或 0 作为参数值。对于不支持“本地布尔”数据类型的后端，还可以在目标列上创建 CHECK 约束的选项
1.2 版本中的变化：Boolean 数据类型现在断言传入的 Python 值已经是纯布尔形式。
成员
init(), bind_processor(), literal_processor(), python_type, result_processor()
类签名
class sqlalchemy.types.Boolean (sqlalchemy.types.SchemaType, sqlalchemy.types.Emulated, sqlalchemy.types.TypeEngine)
method __init__(create_constraint: bool = False, name: str | None = None, _create_events: bool = True, _adapted_from: SchemaType | None = None)
构造一个布尔值。
参数：
create_constraint–
默认为 False。如果布尔值生成为 int/smallint，还会在表上创建一个 CHECK 约束，以确保值为 1 或 0。
注意
强烈建议 CHECK 约束具有明确的名称，以支持模式管理方面的关注。可以通过设置Boolean.name参数或设置适当的命名约定来实现；有关背景信息，请参阅 配置约束命名约定。
1.4 版本中的变化：- 此标志现在默认为 False，表示非本机枚举类型不会生成 CHECK 约束。name– 如果生成了 CHECK 约束，请指定约束的名称。
method bind_processor(dialect)
返回用于处理绑定值的转换函数。
返回一个可调用对象，该对象将接收一个绑定参数值作为唯一位置参数，并返回一个要发送到 DB-API 的值。
如果不需要处理，方法应返回 None。
注意
此方法仅相对于方言特定类型对象调用，该对象通常是方言中使用的私有对象，并且不是公共类型对象，这意味着无法通过子类化TypeEngine类来提供备用的TypeEngine.bind_processor()方法，除非明确地子类化UserDefinedType类。
为了为TypeEngine.bind_processor()提供备用行为，实现一个TypeDecorator类，并提供一个TypeDecorator.process_bind_param()的实现。
另见
增强现有类型
参数：
dialect – 正在使用的方言实例。
method literal_processor(dialect)
返回一个转换函数，用于处理要直接呈现而不使用绑定的文字值。
当编译器使用“literal_binds”标志时，通常在 DDL 生成以及某些后端不接受绑定参数的情况下使用此函数。
返回一个可调用对象，它将接收一个字面 Python 值作为唯一的位置参数，并返回一个字符串表示以在 SQL 语句中呈现。
注意
此方法仅相对于方言特定类型对象调用，该对象通常是方言中使用的私有对象，并且不是公共类型对象，这意味着无法通过子类化TypeEngine类来提供备用的TypeEngine.literal_processor()方法，除非明确地子类化UserDefinedType类。
为了为TypeEngine.literal_processor()提供备用行为，实现一个TypeDecorator类，并提供一个TypeDecorator.process_literal_param()的实现。
另见
增强现有类型
attribute python_type
method result_processor(dialect, coltype)
返回一个用于处理结果行值的转换函数。
返回一个可调用对象，该对象将接收一个结果行列值作为唯一的位置参数，并将返回一个要返回给用户的值。
如果不需要处理，则方法应返回None。
注意
此方法仅相对于特定方言类型对象调用，该对象通常私有于使用的方言，并且不是与公共类型对象相同的类型对象，这意味着不可能通过继承TypeEngine类来提供替代的TypeEngine.result_processor()方法，除非显式地继承UserDefinedType类。
要为TypeEngine.result_processor()提供替代行为，需实现一个TypeDecorator类，并提供一个TypeDecorator.process_result_value()的实现。
另请参见
扩充现有类型
参数：
dialect– 正在使用的方言实例。coltype– 在 cursor.description 中接收到的 DBAPI coltype 参数。
class sqlalchemy.types.Date
用于datetime.date()对象的类型。
成员
get_dbapi_type()，literal_processor()，python_type
类签名
类sqlalchemy.types.Date（sqlalchemy.types._RenderISO8601NoT，sqlalchemy.types.HasExpressionLookup，sqlalchemy.types.TypeEngine）
method get_dbapi_type(dbapi)
返回底层 DB-API 中相应的类型对象（如果有）。
例如，这对于调用setinputsizes()可能很有用。
method literal_processor(dialect)
返回一个用于处理直接呈现而不使用绑定的文字值的转换函数。
当编译器使用“literal_binds”标志时，通常用于 DDL 生成以及某些情况下后端不接受绑定参数时，将使用此函数。
返回一个可调用对象，该对象将接收一个文字 Python 值作为唯一的位置参数，并将返回一个字符串表示以在 SQL 语句中呈现。
注意
这个方法仅在特定方言的类型对象相关时才被调用，这通常是私有于正在使用的方言的，并且不是公共类型对象，这意味着无法通过子类化TypeEngine类来提供替代的TypeEngine.literal_processor()方法，除非明确地子类化UserDefinedType类。
要为 TypeEngine.literal_processor() 提供替代行为，请实现一个 TypeDecorator 类，并提供 TypeDecorator.process_literal_param() 的实现。
另请参阅
扩展现有类型
attribute python_type
class sqlalchemy.types.DateTime
一个用于datetime.datetime()对象的类型。
日期和时间类型返回来自 Python datetime 模块的对象。大多数 DBAPI 都内置支持 datetime 模块，但 SQLite 是个例外。在 SQLite 的情况下，日期和时间类型存储为字符串，然后在返回行时将其转换回 datetime 对象。
在 datetime 类型内的时间表示中，一些后端包括其他选项，例如时区支持和分数秒支持。对于分数秒，使用特定于方言的数据类型，例如TIME。对于时区支持，至少使用TIMESTAMP数据类型，如果不是特定于方言的数据类型对象。
成员
init(), get_dbapi_type(), literal_processor(), python_type
类签名
类 sqlalchemy.types.DateTime (sqlalchemy.types._RenderISO8601NoT, sqlalchemy.types.HasExpressionLookup, sqlalchemy.types.TypeEngine)
method __init__(timezone: bool = False)
构造一个新的 DateTime。
参数：
timezone – 布尔值。指示日期时间类型是否应启用时区支持，如果仅在基本日期/时间保存类型上可用。建议在使用此标志时直接使用TIMESTAMP 数据类型，因为一些数据库包括与支持时区的 TIMESTAMP 数据类型不同的单独的通用日期/时间保存类型，如 Oracle。
method get_dbapi_type(dbapi)
如果有的话，返回底层 DB-API 的相应类型对象。
这对于调用setinputsizes()可能很有用。
method literal_processor(dialect)
返回一个转换函数，用于处理直接呈现而不使用绑定的字面值。
当编译器使用“literal_binds”标志时，通常用于 DDL 生成以及在某些后端不接受绑定参数的情况下使用此函数。
返回一个可调用对象，该对象将接收一个字面的 Python 值作为唯一的位置参数，并返回一个字符串表示，以在 SQL 语句中呈现。
注意
此方法仅相对于特定方言类型对象调用，该对象通常私有于正在使用的方言，并且不是公共类型对象，这意味着不可通过子类化TypeEngine 类来提供替代的TypeEngine.literal_processor() 方法，除非显式地子类化UserDefinedType 类。
要为TypeEngine.literal_processor() 提供替代行为，请实现一个TypeDecorator 类，并提供一个TypeDecorator.process_literal_param() 的实现。
另请参阅
扩展现有类型
attribute python_type
class sqlalchemy.types.Enum
通用枚举类型。
Enum 类型提供了一组可能的字符串值，列受其约束。
如果可用，Enum 类型将使用后端的本机“ENUM”类型；否则，它使用 VARCHAR 数据类型。还存在一个选项，即在生成 VARCHAR（所谓的“非本机”）变体时自动生成 CHECK 约束；请参阅Enum.create_constraint 标志。
Enum 类型在 Python 中也提供了对字符串值进行读写操作期间的验证。从结果集中读取数据库中的值时，始终检查字符串值是否与可能值列表匹配，如果找不到匹配项，则引发 LookupError。在将值作为 SQL 语句中的纯字符串传递给数据库时，如果 Enum.validate_strings 参数设置为 True，则对于未位于给定可能值列表中的任何字符串值，都会引发 LookupError；请注意，这会影响到具有枚举值的 LIKE 表达式的使用（这是一个不寻常的用例）。
枚举值的来源可以是字符串值列表，或者是符合 PEP-435 的枚举类。对于 Enum 数据类型，此类只需要提供一个 __members__ 方法即可。
当使用枚举类时，枚举对象用于输入和输出，而不是字符串，就像普通字符串枚举类型一样：
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
在上面，每个元素的字符串名称（例如“one”、“two”、“three”）都会被持久化到数据库中；Python 枚举的值，这里表示为整数，不会被使用；因此，每个枚举的值可以是任何类型的 Python 对象，无论它是否可持久化。
为了持久化值而不是名称，可以使用 Enum.values_callable 参数。该参数的值是一个用户提供的可调用对象，旨在与符合 PEP-435 的枚举类一起使用，并返回要持久化的字符串值列表。对于使用字符串值的简单枚举，像 lambda x: [e.value for e in x] 这样的可调用对象就足够了。
另见
在类型映射中使用 Python 枚举或 pep-586 Literal 类型 - 使用 ORM 的 ORM 注释声明 功能时，关于在类型映射中使用 Enum 数据类型的背景信息。
ENUM - PostgreSQL 特定类型，具有额外的功能。
ENUM - MySQL 特定类型
成员
init(), create(), drop()
类签名
类sqlalchemy.types.Enum（sqlalchemy.types.String，sqlalchemy.types.SchemaType，sqlalchemy.types.Emulated，sqlalchemy.types.TypeEngine）
method __init__(*enums: object, **kw: Any)
构造枚举。
不适用于特定后端的关键字参数将被该后端忽略。
参数：
*enums– 要么正好一个符合 PEP-435 标准的枚举类型，要么一个或多个字符串标签。create_constraint–
默认为 False。创建非本地枚举类型时，还在数据库上构建 CHECK 约束以针对有效值。
注意
强烈建议为 CHECK 约束指定显式名称，以支持模式管理方面的问题。这可以通过设置Enum.name参数或设置适当的命名约定来实现；有关背景，请参见配置约束命名约定。
自版本 1.4 更改： - 此标志现在默认为 False，意味着对非本地枚举类型不会生成 CHECK 约束。metadata–
将此类型直接关联到MetaData对象。对于作为独立模式构造存在于目标数据库上的类型（如 PostgreSQL），此类型将在create_all()和drop_all()操作中创建和删除。如果该类型未与任何MetaData对象相关联，则它将与使用它的每个Table相关联，并且将在创建任何这些单独表时创建，并在检查其存在后创建。但是，仅在对该Table对象的元数据调用drop_all()时才会删除该类型。
如果设置了MetaData对象的MetaData.schema参数的值，并且未显式提供值，则将使用该对象上的Enum.schema的默认值。
自版本 1.4.12 更改：Enum如果传递使用Enum.metadata参数时继承MetaData对象的MetaData.schema参数（如果存在）。name– 此类型的名称。这对于 PostgreSQL 和任何将来需要显式命名类型或显式命名约束以生成使用它的类型和/或表的支持数据库是必需的。如果使用了 PEP-435 枚举类，则默认情况下使用其名称（转换为小写）。native_enum– 在可用时使用数据库的本机 ENUM 类型。默认为 True。当为 False 时，对所有后端使用 VARCHAR + 检查约束。当为 False 时，如果 native_enum=True，则“length”将被忽略。length–
允许在使用非本机枚举数据类型时为 VARCHAR 指定自定义长度。默认情况下，它使用最长值的长度。
从版本 2.0.0 开始更改：无条件地使用Enum.length参数进行VARCHAR渲染，而不管Enum.native_enum参数的设置情况，对于那些使用VARCHAR作为枚举数据类型的后端。schema–
此类型的模式名称。对于作为独立模式构造存在于目标数据库上的类型（PostgreSQL），此参数指定了类型存在的命名模式。
如果不存在，则在传递为Enum.metadata的MetaData中获取模式名称，对于包含MetaData.schema参数的MetaData。
从版本 1.4.12 开始更改：如果使用Enum.metadata参数传递，则Enum继承了MetaData对象的MetaData.schema参数（如果存在）。
否则，如果Enum.inherit_schema标志设置为True，则模式将从相关的Table对象继承，如果有的话；当Enum.inherit_schema处于默认值False时，不使用所属表的模式。quote– 为类型的名称设置明确的引用首选项。inherit_schema– 当为True时，将从所属Table的schema复制到此Enum的schema属性中，替换传递给schema属性的任何值。这也会在使用Table.to_metadata()操作时生效。validate_strings– 当为 True 时，将传递给 SQL 语句的字符串值将被检查是否有效。未识别的值将引发LookupError。values_callable–
一个可调用对象，将传递符合 PEP-435 的枚举类型，然后应返回要持久化的字符串值列表。这允许替代用法，例如使用枚举的字符串值而不是其名称持久化到数据库中。可调用对象必须以与迭代枚举的__member__属性相同的顺序返回要持久化的值。例如lambda x: [i.value for i in x]。
从版本 1.2.3 起新增。sort_key_function–
可以作为 Pythonsorted()内置函数中的“key”参数使用的 Python 可调用对象。SQLAlchemy ORM 要求映射的主键列必须以某种方式可排序。当使用不可排序的枚举对象，如 Python 3 的Enum对象时，可以使用此参数为对象设置默认的排序键函数。默认情况下，枚举的数据库值被用作排序函数。
从版本 1.3.8 起新增。omit_aliases–
当为 true 时，将从 pep 435 枚举中删除别名的布尔值。默认为True。
自版本 2.0 起更改：此参数现在默认为 True。
method create(bind, checkfirst=False)
继承自 SchemaType.create() 方法的 SchemaType
如适用，为此类型发出 CREATE DDL。
method drop(bind, checkfirst=False)
继承自 SchemaType.drop() 方法的 SchemaType
如适用，为此类型发出 DROP DDL。
class sqlalchemy.types.Double
用于双 FLOAT 浮点类型的类型。
通常在 DDL 中生成 DOUBLE 或 DOUBLE_PRECISION，否则在 Python 方面的行为类似于普通的 Float。
从版本 2.0 起新增。
类签名
类 sqlalchemy.types.Double (sqlalchemy.types.Float)
class sqlalchemy.types.Float
表示浮点类型的类型，例如 FLOAT 或 REAL。
默认情况下，此类型返回 Python float对象，除非将Float.asdecimal标志设置为True，在这种情况下，它们将被强制转换为decimal.Decimal对象。
当Float.precision在Float类型中未提供时，某些后端可能将此类型编译为 8 字节/64 位浮点数据类型。要使用 4 字节/32 位浮点数据类型，通常可以提供精度<= 24，或者可以使用REAL类型。已知在将类型呈现为FLOAT的 PostgreSQL 和 MSSQL 方言中，这种情况是成立的，这两者都是DOUBLE PRECISION的别名。其他第三方方言可能具有类似的行为。
成员
init(), result_processor()
类签名
类sqlalchemy.types.Float（sqlalchemy.types.Numeric）
method __init__(precision: int | None = None, asdecimal: bool = False, decimal_return_scale: int | None = None)
构造一个浮点数。
参数：
precision–
用于在 DDLCREATE TABLE中使用的数字精度。后端应该尝试确保此精度指示了通用Float数据类型的数字位数。
注意
对于 Oracle 后端，在渲染 DDL 时，不接受Float.precision参数，因为 Oracle 不支持将浮点精度指定为小数位数。相反，请使用特定于 Oracle 的FLOAT数据类型，并指定FLOAT.binary_precision参数。这是 SQLAlchemy 2.0 版本中的新功能。
要创建一个数据库通用的Float，并为 Oracle 单独指定二进制精度，请使用TypeEngine.with_variant()如下所示：
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") )
asdecimal– 与Numeric相同的标志，但默认为False。请注意，将此标志设置为True会导致浮点数转换。decimal_return_scale– 在将浮点数转换为 Python 小数时使用的默认精度。由于十进制的不准确性，浮点值通常会更长，而大多数浮点数据库类型没有“精度”的概念，因此默认情况下，当转换时，浮点类型将查找前十位小数。指定此值将覆盖该长度。请注意，如果未另行指定，则 MySQL 浮点类型将使用“精度”作为decimal_return_scale的默认值。
method result_processor(dialect, coltype)
返回一个用于处理结果行值的转换函数。
返回一个可调用对象，该对象将接收一个结果行列值作为唯一的位置参数，并将返回一个要返回给用户的值。
如果不需要处理，该方法应返回None。
注意
此方法仅相对于一个方言特定类型对象调用，该对象通常是正在使用的方言中的私有对象，并且不是与公共对象相同的类型对象，这意味着无法子类化TypeEngine类以提供替代TypeEngine.result_processor()方法，除非明确子类化UserDefinedType类。
要为TypeEngine.result_processor()提供替代行为，请实现TypeDecorator类，并提供TypeDecorator.process_result_value()的实现。
另请参阅
扩充现有类型
参数：
方言– 正在使用的方言实例。coltype– 在 cursor.description 中接收的 DBAPI coltype 参数。
class sqlalchemy.types.Integer
一种适用于int整数的类型。
成员
get_dbapi_type()，literal_processor()，python_type
类签名
类sqlalchemy.types.Integer (sqlalchemy.types.HasExpressionLookup, sqlalchemy.types.TypeEngine)
method get_dbapi_type(dbapi)
如果有的话，返回底层 DB-API 的相应类型对象。
例如，这对于调用setinputsizes()可能很有用。
method literal_processor(dialect)
返回一个用于处理直接呈现的字面值的转换函数，而无需使用绑定。
此函数在编译器使用 “literal_binds” 标志时使用，通常用于 DDL 生成以及在某些后端不接受绑定参数的情况下。
返回一个可调用对象，该对象将接收一个字面的 Python 值作为唯一的位置参数，并返回一个字符串表示以在 SQL 语句中呈现。
注意
此方法仅相对于 特定方言类型对象 调用，该对象通常是 特定方言私有的，并且与公共类型对象不同，这意味着不可能通过子类化 TypeEngine 类来提供替代的 TypeEngine.literal_processor() 方法，除非显式子类化 UserDefinedType 类。
要为 TypeEngine.literal_processor() 提供替代行为，请实现一个 TypeDecorator 类，并提供 TypeDecorator.process_literal_param() 的实现。
另请参阅
扩展现有类型
attribute python_type
class sqlalchemy.types.Interval
用于 datetime.timedelta() 对象的类型。
Interval 类型处理 datetime.timedelta 对象。在 PostgreSQL 和 Oracle 中，使用原生的 INTERVAL 类型；对于其他数据库，该值存储为相对于“epoch”（1970 年 1 月 1 日）的日期。
请注意，Interval 类型当前在不原生支持间隔类型的平台上不提供日期算术操作。这些操作通常需要对表达式的两侧进行转换（例如，首先将两侧转换为整数时期值），目前这是一个手动过程（例如，通过 expression.func）。
成员
init(), adapt_to_emulated(), bind_processor(), cache_ok, coerce_compared_value(), comparator_factory, impl, python_type, result_processor()
类签名
类sqlalchemy.types.Interval (sqlalchemy.types.Emulated, sqlalchemy.types._AbstractInterval, sqlalchemy.types.TypeDecorator)
class Comparator
类签名
类sqlalchemy.types.Interval.Comparator (sqlalchemy.types.Comparator, sqlalchemy.types.Comparator)
method __init__(native: bool = True, second_precision: int | None = None, day_precision: int | None = None)
构造一个 Interval 对象。
参数：
native– 当为 True 时，如果支持（目前是 PostgreSQL、Oracle），则使用数据库提供的实际 INTERVAL 类型。否则，无论如何都将间隔数据表示为时代值。second_precision– 对于支持“分秒精度”参数的本机间隔类型，例如 Oracle 和 PostgreSQLday_precision– 对于支持“天精度”参数的本机间隔类型，例如 Oracle。
method adapt_to_emulated(impltype, **kw)
给定一个 impl 类，将此类型适配到 impl，假设“模拟”。
impl 还应该是此类型的“模拟”版本，很可能是与此类型本身相同的类。
例如：sqltypes.Enum 适应于 Enum 类。
method bind_processor(dialect: Dialect) → _BindProcessorType[dt.timedelta]
返回一个用于处理绑定值的转换函数。
返回一个可调用对象，该对象将接收绑定参数值作为唯一的位置参数，并返回要发送到 DB-API 的值。
如果不需要处理，则该方法应返回None。
注
此方法仅相对于特定方言类型对象调用，该对象通常是正在使用的方言的私有对象，并且不是公共类型对象，这意味着无法通过子类化TypeEngine类来提供替代的TypeEngine.bind_processor()方法，除非显式地对UserDefinedType类进行子类化。
要为TypeEngine.bind_processor()提供替代行为，请实现一个TypeDecorator类，并提供TypeDecorator.process_bind_param()的实现。
另请参见
扩展现有类型
参数：
方言 – 正在使用的方言实例。
attribute cache_ok: bool | None = True
指示使用此ExternalType的语句是否“安全缓存”。
默认值None会发出警告，然后不允许缓存包含此类型的语句。设置为False以禁用完全不带警告缓存使用此类型的语句。当设置为True时，将使用对象的类和其状态的选定元素作为缓存键的一部分。例如，使用TypeDecorator:
class MyType(TypeDecorator): impl = String cache_ok = True def __init__(self, choices): self.choices = tuple(choices) self.internal_only = True
上述类型的缓存键将等同于：
>>> MyType(["a", "b", "c"])._static_cache_key (<class '__main__.MyType'>, ('choices', ('a', 'b', 'c')))
缓存方案将从类型中提取与__init__()方法中参数名称对应的属性。上面的“choices”属性成为缓存键的一部分，但“internal_only”不会，因为没有名为“internal_only”的参数。
可缓存元素的要求是它们是可哈希的，并且它们指示对于给定缓存值的表达式每次返回相同的 SQL 渲染。
为了适应引用不可哈希结构（如字典、集合和列表）的数据类型，这些对象可以通过将可哈希结构分配给与参数名称对应的属性来“可缓存”。例如，一个接受查找值字典的数据类型可以将其发布为排序后的元组序列。假设以前不可缓存的类型如下：
class LookupType(UserDefinedType): '''a custom type that accepts a dictionary as a parameter. this is the non-cacheable version, as "self.lookup" is not hashable. ''' def __init__(self, lookup): self.lookup = lookup def get_col_spec(self, **kw): return "VARCHAR(255)" def bind_processor(self, dialect): # ... works with "self.lookup" ...
其中“lookup”是一个字典。该类型将无法生成缓存键：
>>> type_ = LookupType({"a": 10, "b": 20}) >>> type_._static_cache_key <stdin>:1: SAWarning: UserDefinedType LookupType({'a': 10, 'b': 20}) will not produce a cache key because the ``cache_ok`` flag is not set to True. Set this flag to True if this type object's state is safe to use in a cache key, or False to disable this warning. symbol('no_cache')
如果我们确实设置了这样一个缓存键，它将无法使用。我们将得到一个包含字典的元组结构，该字典本身不能用作“缓存字典”中的键，例如 SQLAlchemy 的语句缓存，因为 Python 字典不可哈希：
>>> # set cache_ok = True >>> type_.cache_ok = True >>> # this is the cache key it would generate >>> key = type_._static_cache_key >>> key (<class '__main__.LookupType'>, ('lookup', {'a': 10, 'b': 20})) >>> # however this key is not hashable, will fail when used with >>> # SQLAlchemy statement cache >>> some_cache = {key: "some sql value"} Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: 'dict'
通过将排序后的元组分配给“lookup”属性，可以使类型成为可缓存的：
class LookupType(UserDefinedType): '''a custom type that accepts a dictionary as a parameter. The dictionary is stored both as itself in a private variable, and published in a public variable as a sorted tuple of tuples, which is hashable and will also return the same value for any two equivalent dictionaries. Note it assumes the keys and values of the dictionary are themselves hashable. ''' cache_ok = True def __init__(self, lookup): self._lookup = lookup # assume keys/values of "lookup" are hashable; otherwise # they would also need to be converted in some way here self.lookup = tuple( (key, lookup[key]) for key in sorted(lookup) ) def get_col_spec(self, **kw): return "VARCHAR(255)" def bind_processor(self, dialect): # ... works with "self._lookup" ...
在上述情况下，LookupType({"a": 10, "b": 20})的缓存键将是：
>>> LookupType({"a": 10, "b": 20})._static_cache_key (<class '__main__.LookupType'>, ('lookup', (('a', 10), ('b', 20))))
新版本 1.4.14 中新增：- 添加了 cache_ok 标志，以允许对 TypeDecorator 类进行某些缓存配置。
新版本 1.4.28 中新增：- 添加了 ExternalType 混合类，它将 cache_ok 标志推广到 TypeDecorator 和 UserDefinedType 类。
另请参阅
SQL 编译缓存
method coerce_compared_value(op, value) • 1
在表达式中为‘coerced’ Python 值建议一个类型。
给定一个运算符和值，使类型有机会返回一个值应该被强制转换为的类型。
这里的默认行为是保守的；如果右侧已根据其 Python 类型强制转换为 SQL 类型，则通常会保持不变。
此处的最终用户功能扩展通常应通过 TypeDecorator 实现，该实现具有更宽松的行为，因为它默认将表达式的另一侧强制转换为此类型，从而对除 DBAPI 需要的特殊 Python 转换之外的内容进行应用。它还提供了 TypeDecorator.coerce_compared_value() 的公共方法，该方法用于最终用户自定义此行为。
attribute comparator_factory
别名 Comparator
attribute impl
别名 DateTime
attribute python_type
method result_processor(dialect: Dialect, coltype: Any) → _ResultProcessorType[dt.timedelta]
返回一个用于处理结果行值的转换函数。
返回一个可调用对象，该对象将接收一个结果行列值作为唯一的位置参数，并将返回一个要返回给用户的值。
如果不需要处理，方法应返回None。
注
仅相对于方言特定类型对象调用此方法，该对象通常私有于正在使用的方言，并且与公共面向对象不同，这意味着无法通过子类化 TypeEngine 类来提供替代的 TypeEngine.result_processor() 方法，除非显式地子类化 UserDefinedType 类。
要为 TypeEngine.result_processor() 提供替代行为，实现一个 TypeDecorator 类并提供 TypeDecorator.process_result_value() 的实现。
另请参见
扩展现有类型
参数：
dialect– 正在使用的方言实例。coltype– 在 cursor.description 中接收到的 DBAPI coltype 参数。
class sqlalchemy.types.LargeBinary
用于大型二进制字节数据的类型。
LargeBinary 类型对应于目标平台的大型和/或无长度的二进制类型，例如 MySQL 上的 BLOB 和 PostgreSQL 上的 BYTEA。它还处理了 DBAPI 的必要转换。
成员
init()
类签名
类 sqlalchemy.types.LargeBinary (sqlalchemy.types._Binary)
method __init__(length: int | None = None)
构造一个大型二进制类型。
参数：
长度 – 可选，用于 DDL 语句的列长度，用于那些接受长度的二进制类型，例如 MySQL 的 BLOB 类型。
class sqlalchemy.types.MatchType
指的是 MATCH 操作符的返回类型。
由于 ColumnOperators.match() 可能是 SQLAlchemy 核心中最开放的运算符，我们不能在 SQL 评估时假设返回类型，因为 MySQL 返回浮点数而不是布尔值，其他后端可能会执行不同的操作。因此，此类型充当占位符，目前是 Boolean 的子类。该类型允许方言在需要时注入结果处理功能，在 MySQL 上将返回浮点值。
SqlAlchemy 2.0 中文文档（四十一）（4）https://developer.aliyun.com/article/1563083
