类型层次结构¶

SQLAlchemy 为最常见的数据库数据类型提供抽象，以及自定义数据类型的多种技术。

数据库类型使用 Python 类表示，所有这些类最终都从称为 TypeEngine 的基类型类扩展而来。数据类型有两种一般类别，每种数据类型都以不同的方式在类型层次结构中表达自己。单个数据类型类使用的类别可以根据两种不同的命名约定（即 “CamelCase” 和 “UPPERCASE”）来标识。

另请参阅

使用 Table 对象设置 MetaData - 在 SQLAlchemy Unified Tutorial 中。阐释了 TypeEngine 类型对象在定义 Table 元数据方面的最基本用法，并以教程的形式介绍了类型对象的概念。

“CamelCase” 数据类型¶

基本类型具有 “CamelCase” 名称，例如 String、 Numeric、Integer 和 DateTime 的 Integer 和 DateTime 中。TypeEngine 的所有直接子类都是 “CamelCase” 类型。“CamelCase” 类型在最大程度上是可能的 数据库不可知，这意味着它们都可以在任何数据库后端使用，在那里它们将以适合该后端的方式运行，以产生所需的行为。

一个简单的 “CamelCase” 数据类型示例是 String。在大多数后端，在表规范将对应于 VARCHAR 数据库类型，用于向数据库传递字符串值或从数据库传递字符串值，如下例所示：

from sqlalchemy import MetaData
from sqlalchemy import Table, Column, Integer, String

metadata_obj = MetaData()

user = Table(
    "user",
    metadata_obj,
    Column("user_name", String, primary_key=True),
    Column("email_address", String(60)),
)

在 表定义或任何 SQL 表达式中，如果不需要任何参数，则可以将其作为类本身传递，即无需使用 （） 实例化它。如果需要参数，例如上面 “email_address” 列中的 length 参数 60，则可以实例化该类型。

另一种表示更多后端特定行为的 “CamelCase” 数据类型是 Boolean 数据类型。与 String 不同，String 表示所有数据库都具有的字符串数据类型，并非每个后端都有真正的 “boolean” 数据类型;有些使用整数或 BIT 值 0 和 1，有些具有布尔文本常量 true 和 false，而其他则不然。对于此数据类型，布尔值可以在后端（如 PostgreSQL）、BIT 在 MySQL 后端和 SMALLINT 在 Oracle 数据库上呈现。由于使用此类型从数据库发送和接收数据，因此根据所使用的方言，它可能会解释 Python 数字或布尔值。

在一般情况下，典型的 SQLAlchemy 应用程序可能希望主要使用 “CamelCase” 类型，因为它们通常会提供最佳的基本行为并自动移植到所有后端。

“CamelCase”数据类型的一般集合的参考如下泛型 “CamelCase” 类型。

“UPPERCASE” 数据类型¶

与 “CamelCase” 类型相反的是 “UPPERCASE” 数据类型。这些数据类型总是从特定的 “CamelCase” 数据类型继承来的，并且总是表示一个精确的数据类型。当使用 “UPPERCASE” 数据类型时，类型的名称始终完全按照给定的方式呈现，而不考虑当前后端是否支持它。因此，在 SQLAlchemy 应用程序中使用 “UPPERCASE” 类型表明需要特定的数据类型，这意味着应用程序通常不会采取额外的步骤，仅限于那些完全按照给定方式使用该类型的后端。UPPERCASE 类型的示例包括 VARCHAR、NUMERIC、 INTEGER 和 TIMESTAMP，它们直接继承来自前面提到的 “CamelCase” 类型 字符串、分别是 Numeric、Integer 和 DateTime。

作为 sqlalchemy.types 一部分的 “UPPERCASE” 数据类型是常见的 SQL 类型，通常希望至少在两个后端可用，如果不是更多的话。

一般的 “UPPERCASE” 数据类型集的参考如下 SQL 标准和多个供应商 “UPPERCASE” 类型。

后端特定的 “UPPERCASE” 数据类型¶

大多数数据库也有自己的数据类型，这些数据类型要么完全特定于这些数据库，要么添加特定于这些数据库的其他参数。对于这些数据类型，特定的 SQLAlchemy 方言为在其他后端没有类似物的 SQL 类型提供特定于后端的 “UPPERCASE” 数据类型。特定于后端的大写数据类型的示例包括 PostgreSQL 的 JSONB、SQL Server 的 IMAGE 和 MySQL 的 TINYTEXT.

特定后端还可能包括扩展参数可从与 sqlalchemy.types 模块。例如，在创建 MySQL 字符串数据类型时，可能需要指定特定于 MySQL 的参数，例如 charset 或 national，它们可从 VARCHAR 的 MySQL 版本中作为仅限 MySQL 的参数获得 VARCHAR.charset 和 VARCHAR.national。

后端特定类型的 API 文档位于方言特定文档中，列在方言中。

为多个后端使用 “UPPERCASE” 和特定于 Backend 的类型¶

查看 “UPPERCASE” 和 “CamelCase” 类型的存在会导致如何将 “UPPERCASE” 数据类型用于特定于后端的选项的自然用例，但前提是该后端正在使用。为了将数据库无关的 “CamelCase” 和后端特定的 “UPPERCASE” 系统联系在一起，可以使用 TypeEngine.with_variant（） 方法，以便 Compose 类型一起使用，以处理特定后端上的特定行为。

例如，使用 String 数据类型，但在 MySQL 上运行时，使用 VARCHAR.charset 参数 VARCHAR 在 MySQL 或 MariaDB 上创建表时， 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），它将呈现为 VARCHAR(255) CHARACTER SET utf8 .

另请参阅

TypeEngine.with_variant（） - 其他用法示例和说明

泛型 “CamelCase” 类型¶

泛型类型指定一个可以读取、写入和存储特定类型的 Python 数据。 SQLAlchemy 将选择最好的 database 列类型在目标数据库上可用。 CREATE TABLE 语句。要完全控制在 CREATE TABLE 中发出的列类型，例如 VARCHAR，请参阅 SQL 标准和多供应商 “UPPERCASE” 类型以及本章的其他部分。

对象名称	描述
BigInteger （大整数）	用于较大 `int` 整数的类型。
布尔	一个 bool 数据类型。
日期	`datetime.date（）` 对象的类型。
日期时间	`datetime.datetime（）` 对象的类型。
双	双精度 `FLOAT` 浮点类型的类型。
枚举	泛型 Enum 类型。
浮	表示浮点类型的类型，例如 `FLOAT` 或 `REAL`。
整数	`int` 整数的类型。
间隔	`datetime.timedelta（）` 对象的类型。
LargeBinary	用于大型二进制字节数据的类型。
匹配类型	指 MATCH 运算符的返回类型。
数值的	非整数数值类型的 Base，例如 `NUMERIC、FLOAT、DECIMAL` 和其他变体。
PickleType （泡菜类型）	保存 Python 对象，这些对象使用 pickle 进行序列化。
架构类型	向类型添加功能，以允许架构级 DDL 与类型相关联。
SmallInteger	用于较小 `int` 整数的类型。
字符串	所有字符串和字符类型的基数。
发短信	可变大小的字符串类型。
时间	`datetime.time（）` 对象的类型。
统一码	可变长度的 Unicode 字符串类型。
Unicode文本	无限长度的 Unicode 字符串类型。
儘	表示与数据库无关的 UUID 数据类型。

类 sqlalchemy.types 中。BigInteger 函数¶

用于较大 int 整数的类型。

通常在 DDL 中生成 BIGINT，否则在 Python 端的行为类似于普通的 Integer。

类签名

类 sqlalchemy.types.BigInteger （sqlalchemy.types.Integer）

类 sqlalchemy.types 中。布尔值¶

一个 bool 数据类型。

Boolean 通常在 DDL 端使用 BOOLEAN 或 SMALLINT，而在 Python 端处理 True 或 False。

布尔数据类型当前有两个级别的断言，即保留的值是简单的 true/false 值。对于所有后端，只有 Python 值 None、True、False、1 或 0 作为参数值。对于那些不支持 “native boolean” 数据类型的后端，存在一个选项可以在目标列上创建 CHECK 约束

在 1.2 版本发生变更： Boolean 数据类型现在断言传入的 Python 值已经是纯布尔形式。

成员

__init__（）、bind_processor（）、literal_processor（）、python_type、result_processor（）

类签名

类 sqlalchemy.types.Boolean （sqlalchemy.types.SchemaType， sqlalchemy.types.Emulated， sqlalchemy.types.TypeEngine）

方法 sqlalchemy.types.Boolean 中。__init__（create_constraint： bool = False， name：strNone=None， _create_events： bool = True， _adapted_from：SchemaTypeNone=None）¶

构造一个布尔值。

参数

create_constraint¶ –

默认为 False。如果布尔值生成为 int/smallint，则还要在表上创建一个 CHECK 约束，以确保值为 1 或 0。

注意

强烈建议将 CHECK 约束具有显式名称，以便支持 Schema-Management 关注。这可以通过设置 Boolean.name 参数中，或者通过设置适当的命名约定;看为背景配置 Constraint Naming Conventions。

在 1.4 版本发生变更： - 此标志现在默认为 False，这意味着不会为非本机枚举类型生成 CHECK 约束。
name¶– 如果生成了 CHECK 约束，请指定约束的名称。

方法 sqlalchemy.types.Boolean 中。bind_processor（方言）¶

返回用于处理绑定值的转换函数。

返回一个可调用对象，该对象将接收一个 bind 参数值作为唯一的位置参数，并将返回一个值以发送到 DB-API。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.bind_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.bind_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_bind_param() .

另请参阅

扩充现有类型

参数: dialect¶– 正在使用的 Dialect 实例。

方法 sqlalchemy.types.Boolean 中。literal_processor（方言）¶

返回一个转换函数，用于处理要直接呈现的文本值，而无需使用绑定。

当编译器使用 “literal_binds” 标志时，将使用此函数，该标志通常用于 DDL 生成以及后端不接受绑定参数的某些场景。

返回一个可调用对象，该对象将接收一个文字 Python 值作为唯一的位置参数，并将返回一个字符串表示形式，以便在 SQL 语句中呈现。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.literal_processor() 类而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.literal_processor() ，实现 TypeDecorator 类并提供 TypeDecorator.process_literal_param() .

另请参阅

扩充现有类型

属性 sqlalchemy.types.Boolean 中。python_type¶

方法 sqlalchemy.types.Boolean 中。result_processor（方言，同类型）¶

返回用于处理结果行值的转换函数。

返回一个可调用对象，该对象将接收结果行列值作为唯一的位置参数，并将返回一个值以返回给用户。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.result_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.result_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_result_value() .

另请参阅

扩充现有类型

参数

dialect¶– 正在使用的 Dialect 实例。
coltype¶– 在 cursor.description 中接收的 DBAPI coltype 参数。

类 sqlalchemy.types 中。日期¶

datetime.date（） 对象的类型。

成员

get_dbapi_type（）、literal_processor（）python_type

类签名

类 sqlalchemy.types.Date （ sqlalchemy.types._RenderISO8601NoT ， sqlalchemy.types.HasExpressionLookup ， sqlalchemy.types.TypeEngine）

方法 sqlalchemy.types.Date 中。get_dbapi_type（dbapi）¶

从底层 DB-API 返回相应的类型对象（如果有）。

例如，这对于调用 setinputsizes（） 很有用。

方法 sqlalchemy.types.Date 中。literal_processor（方言）¶

返回一个转换函数，用于处理要直接呈现的文本值，而无需使用绑定。

当编译器使用 “literal_binds” 标志时，将使用此函数，该标志通常用于 DDL 生成以及后端不接受绑定参数的某些场景。

返回一个可调用对象，该对象将接收一个文字 Python 值作为唯一的位置参数，并将返回一个字符串表示形式，以便在 SQL 语句中呈现。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.literal_processor() 类而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.literal_processor() ，实现 TypeDecorator 类并提供 TypeDecorator.process_literal_param() .

另请参阅

扩充现有类型

属性 sqlalchemy.types.Date 的 Types.python_type¶

类 sqlalchemy.types 中。日期时间¶

datetime.datetime（） 对象的类型。

日期和时间类型从 Python 日期时间返回对象模块。大多数 DBAPI 都内置了对日期时间的支持模块，但 SQLite 例外。在 SQLite、日期和时间类型存储为字符串，然后返回 rows 时转换回 DateTime 对象。

对于 datetime 类型中的时间表示形式，某些后端包含其他选项，例如时区支持和秒的小数部分支持。对于秒的小数部分，请使用特定于方言的数据类型，例如 TIME。对于时区支持，如果不是特定于方言的数据类型对象，请至少使用 TIMESTAMP 数据类型。

成员

__init__（）、get_dbapi_type（）、literal_processor（）python_type

类签名

类 sqlalchemy.types.DateTime （ sqlalchemy.types._RenderISO8601NoT ， sqlalchemy.types.HasExpressionLookup ， sqlalchemy.types.TypeEngine）

方法 sqlalchemy.types.DateTime 中。__init__（时区： bool = False）¶

构造新的 DateTime。

参数: timezone¶ – 布尔值。指示 datetime 类型应启用 Timezone Support（如果 仅限基准日期/时间持有类型。建议在使用此标志时直接使用 TIMESTAMP 数据类型，因为某些数据库包含与支持时区的 TIMESTAMP 数据类型不同的单独通用日期/时间保持类型，例如 Oracle Database。

方法 sqlalchemy.types.DateTime 中。get_dbapi_type（dbapi）¶

从底层 DB-API 返回相应的类型对象（如果有）。

例如，这对于调用 setinputsizes（） 很有用。

方法 sqlalchemy.types.DateTime 中。literal_processor（方言）¶

返回一个转换函数，用于处理要直接呈现的文本值，而无需使用绑定。

当编译器使用 “literal_binds” 标志时，将使用此函数，该标志通常用于 DDL 生成以及后端不接受绑定参数的某些场景。

返回一个可调用对象，该对象将接收一个文字 Python 值作为唯一的位置参数，并将返回一个字符串表示形式，以便在 SQL 语句中呈现。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.literal_processor() 类而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.literal_processor() ，实现 TypeDecorator 类并提供 TypeDecorator.process_literal_param() .

另请参阅

扩充现有类型

属性 sqlalchemy.types.DateTime 的python_type¶

类 sqlalchemy.types 中。枚举¶

泛型 Enum 类型。

Enum 类型提供了一组可能的字符串值，列被约束到这些值。

Enum 类型将使用后端的原生 “ENUM” 类型（如果可用）;否则，它使用 VARCHAR 数据类型。还有一个选项可以在生成 VARCHAR （所谓的 “非本机” ）变体时自动生成 CHECK 约束;请参阅 Enum.create_constraint 标志。

Enum 类型还在读取和写入作期间提供字符串值的 Python 内验证。在结果集中从数据库中读取值时，始终根据可能的值列表检查字符串值，并引发 LookupError 如果未找到匹配项。将值作为 plain 字符串，如果 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 的枚举类一起使用，并返回要保留的字符串值列表。对于使用字符串值的简单枚举，像 SUCH 这样的 lambda x: [e.value for e in x] 可调用对象就足够了。

另请参阅

在类型映射中使用 Python Enum 或 pep-586 Literal 类型 - 将 Enum 数据类型与 ORM 的 ORM 注释声明式特征。

ENUM - 特定于 PostgreSQL 的类型，具有其他功能。

ENUM - 特定于 MySQL 的类型

成员

__init__（）、create（）、drop（）

类签名

类 sqlalchemy.types.Enum （sqlalchemy.types.String， sqlalchemy.types.SchemaType， sqlalchemy.types.Emulated， sqlalchemy.types.TypeEngine）

方法 sqlalchemy.types.Enum 中。__init__（*enums： object， **kw： Any）¶

构造一个枚举。

不适用于特定后端的关键字参数将被该后端忽略。

参数

枚举¶——要么是一个符合 PEP-435 标准的枚举类型，要么是一个或多个字符串标签。
create_constraint¶ –

默认为 False。在创建非本机枚举类型时，还要根据有效值在数据库上构建 CHECK 约束。

注意

强烈建议将 CHECK 约束具有显式名称，以便支持 Schema-Management 关注。这可以通过设置 Enum.name 参数中，或者通过设置适当的命名约定;看为背景配置 Constraint Naming Conventions。

在 1.4 版本发生变更： - 此标志现在默认为 False，这意味着不会为非本机枚举类型生成 CHECK 约束。
元数据¶ –

将此类型直接与 MetaData 关联对象。对于作为独立架构构造（PostgreSQL），此类型将为在 create_all（） 和 drop_all（） 中创建和删除操作。如果类型未与任何 MetaData 关联对象，它将自身与使用它的每个 Table 相关联，并在检查其是否存在后，在创建任何这些单独的 table 时创建该 Table。仅当为该 Table 调用 drop_all（） 时，才会删除该类型对象的元数据。

如果未另行提供显式值，则 MetaData 对象的 MetaData.schema 参数的值（如果已设置）将用作此对象上 Enum.schema 的默认值。

在 1.4.12 版本发生变更： Enum 继承了 MetaData.schema 参数的 MetaData 对象（如果存在），当使用 Enum.metadata 参数传递时。
name¶- 此类型的名称。这对于 PostgreSQL 和任何将来支持的数据库来说都是必需的，这些数据库需要显式命名的类型或显式命名的约束才能生成类型和/或使用它的表。如果使用 PEP-435 枚举类，则默认使用其名称（转换为小写）。
native_enum¶– 使用数据库的原生 ENUM 类型（如果可用）。默认为 True。当 False 时，对所有后端使用 VARCHAR + check constraint。当 False 时，VARCHAR 长度可以用 Enum.length 控制;当前，如果 native_enum=True，则忽略 “length”。
长度¶ –

允许在使用非本机枚举数据类型时指定 VARCHAR 的自定义长度。默认情况下，它使用 longest 值的长度。

在 2.0.0 版本发生变更： Enum.length 参数无条件地用于 VARCHAR 渲染，而不管 Enum.native_enum 参数如何，对于将 VARCHAR 用于枚举数据类型的后端。
架构¶ –

此类型的架构名称。对于作为独立架构结构（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，则不使用拥有表的架构。
quote¶– 为类型名称设置显式引用首选项。
inherit_schema¶– 当 True 时，来自拥有的 桌子 将被复制到此 Enum，替换为 schema 属性。这在使用 Table.to_metadata（）作。
validate_strings¶ – 当为 True 时，将根据枚举值列表检查在 SQL 语句中传递给数据库的字符串值的有效性。无法识别的值将导致引发 LookupError。
values_callable¶ –

一个将传递给 PEP-435 的可调用对象 compliant 枚举类型，然后应返回 String 值进行持久化。这允许其他用法，例如使用要持久化到数据库的枚举的字符串值而不是其名称。可调用对象必须返回要为以与遍历 Enum 的 __member__ 属性。例如 lambda x: [i.value for i in x] .

在 1.2.3 版本加入.
sort_key_function¶ –

一个 Python 可调用对象，可以用作 Python builted（） 中的 “key” 参数。SQLAlchemy ORM 要求映射的主键列必须以某种方式可排序。当使用不可排序的枚举对象（如 Python 3 Enum 对象）时，此参数可用于为对象设置默认排序键函数。默认情况下，枚举的 database 值用作排序函数。

在 1.3.8 版本加入.
omit_aliases¶ –

一个布尔值，当 true 时将从 pep 435 枚举中删除别名。默认为 True。

在 2.0 版更改：此参数现在默认为 True。

方法 sqlalchemy.types.Enum 中。create（bind， checkfirst=False）¶: 继承自 SchemaType 的 SchemaType.create（） 方法

为此类型发出 CREATE DDL（如果适用）。

方法 sqlalchemy.types.Enum 中。drop（bind， checkfirst=False）¶: 继承自 SchemaType 的 SchemaType.drop（） 方法

为此类型发出 DROP DDL（如果适用）。

类 sqlalchemy.types 中。双精度¶

双精度 FLOAT 浮点类型的类型。

通常在 DDL 中生成 DOUBLE 或 DOUBLE_PRECISION，否则在 Python 端的行为类似于普通的 Float。

2.0 版的新Function。

类签名

类 sqlalchemy.types.Double （sqlalchemy.types.Float）

类 sqlalchemy.types 中。浮点数¶

表示浮点类型的类型，例如 FLOAT 或 REAL。

默认情况下，此类型返回 Python 浮点对象，除非 Float.asdecimal 标志设置为 True，在这种情况下，它们被强制为 decimal。Decimal 对象。

当 Float.precision 未在 Float 类型，某些后端可能会将此类型编译为一个 8 字节 / 64 位的 float 数据类型。使用 4 字节/32 位浮点数数据类型 a 精度 <= 24 或可以使用 REAL 类型。在 PostgreSQL 和 MSSQL 方言中，已知情况就是这种情况，它们将类型呈现为 FLOAT，该 FLOAT 的别名为 双精度。其他第三方方言可能具有类似的行为。

成员

__init__（）， result_processor（）

类签名

类 sqlalchemy.types.Float （sqlalchemy.types.Numeric）

方法 sqlalchemy.types.Float 中。__init__（precision：intNone=None， asdecimal： bool = False， decimal_return_scale：intNone=None）¶

构造一个浮点数。

参数

精度¶ –

在 DDL CREATE 中使用的数值精度TABLE 的后端应尝试确保此精度表示泛型 Float 数据类型。
注意

对于 Oracle Database 后端，渲染 DDL 时不接受 Float.precision 参数，因为 Oracle Database 不支持指定为小数位数的浮点精度。相反，请使用特定于 Oracle Database 的 FLOAT 数据类型并指定 FLOAT.binary_precision 参数。这是 SQLAlchemy 版本 2.0 中的新增功能。

要创建与数据库无关的 Float，请执行单独指定 Oracle Database 的二进制精度，请使用 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 小数时使用的默认比例。由于十进制的不准确，浮点值通常会长得多，并且大多数浮点数据库类型没有“小数位数”的概念，因此默认情况下，浮点类型在转换时查找前十位小数。指定此值将覆盖该长度。请注意，如果未另行指定，则包含 “scale” 的 MySQL 浮点类型将使用 “scale” 作为 decimal_return_scale 的默认值。

方法 sqlalchemy.types.Float 中。result_processor（方言，同类型）¶

返回用于处理结果行值的转换函数。

返回一个可调用对象，该对象将接收结果行列值作为唯一的位置参数，并将返回一个值以返回给用户。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.result_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.result_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_result_value() .

另请参阅

扩充现有类型

参数

dialect¶– 正在使用的 Dialect 实例。
coltype¶– 在 cursor.description 中接收的 DBAPI coltype 参数。

类 sqlalchemy.types 中。整数¶

int 整数的类型。

成员

get_dbapi_type（）、literal_processor（）python_type

类签名

类 sqlalchemy.types.Integer （ sqlalchemy.types.HasExpressionLookup ， sqlalchemy.types.TypeEngine）

方法 sqlalchemy.types.Integer 中。get_dbapi_type（dbapi）¶

从底层 DB-API 返回相应的类型对象（如果有）。

例如，这对于调用 setinputsizes（） 很有用。

方法 sqlalchemy.types.Integer 中。literal_processor（方言）¶

返回一个转换函数，用于处理要直接呈现的文本值，而无需使用绑定。

当编译器使用 “literal_binds” 标志时，将使用此函数，该标志通常用于 DDL 生成以及后端不接受绑定参数的某些场景。

返回一个可调用对象，该对象将接收一个文字 Python 值作为唯一的位置参数，并将返回一个字符串表示形式，以便在 SQL 语句中呈现。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.literal_processor() 类而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.literal_processor() ，实现 TypeDecorator 类并提供 TypeDecorator.process_literal_param() .

另请参阅

扩充现有类型

属性 sqlalchemy.types.Integer 的 Integer 中。python_type¶

类 sqlalchemy.types 中。间隔¶

datetime.timedelta（） 对象的类型。

Interval 类型处理 datetime.timedelta 对象。在 PostgreSQL 和 Oracle Database 中，使用本机 INTERVAL 类型;对于其他对象，该值存储为相对于“纪元”（1970 年 1 月 1 日）的日期。

请注意，Interval 类型当前不提供日期算术在本身不支持 interval 类型的平台上的作。这样作通常需要转换表达式的两侧（例如，首先将两侧转换为 Integer epoch 值），其中当前是一个手动过程（例如 VIA expression.func 的 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 ）

类 Comparator¶: 类签名

类 sqlalchemy.types.Interval.Comparator （sqlalchemy.types.Comparator， sqlalchemy.types.Comparator）

方法 sqlalchemy.types.Interval 中。__init__（原生： bool = True， second_precision：intNone=None， day_precision：intNone=None）¶

构造 Interval 对象。

参数

native¶ – 当为 True 时，使用数据库提供的实际 INTERVAL 类型（如果支持）（当前为 PostgreSQL、Oracle Database）。否则，无论如何，都将间隔数据表示为 epoch 值。
second_precision¶– 对于支持“秒精度”参数的本机间隔类型，即 Oracle Database 和 PostgreSQL
day_precision¶ – 适用于支持 “day precision” 参数的原生间隔类型，即 Oracle Database。

方法 sqlalchemy.types.Interval 中。adapt_to_emulated（impltype， **kw）¶

给定一个 impl 类，将此类型调整为假设 “emulated” 的 impl。

impl 也应该是此类型的 “模拟” 版本，很可能与此类型本身相同的类。

例如：sqltypes。Enum 适应 Enum 类。

方法 sqlalchemy.types.Interval 中。bind_processor（dialect：方言）→ _BindProcessorType[dt.timedelta]¶

返回用于处理绑定值的转换函数。

返回一个可调用对象，该对象将接收一个 bind 参数值作为唯一的位置参数，并将返回一个值以发送到 DB-API。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.bind_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.bind_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_bind_param() .

另请参阅

扩充现有类型

参数: dialect¶– 正在使用的 Dialect 实例。

属性 sqlalchemy.types.Interval。cache_ok：boolNone = 真¶

指示使用此 ExternalType 的语句是否“可以安全缓存”。

默认值 None 将发出警告，然后不允许缓存包含此类型的语句。设置为 False 可完全禁止缓存使用此类型的语句，而不会显示警告。当设置为 True 时，对象的类和从其 state 将用作缓存键的一部分。例如，使用 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。

为了适应引用不可哈希结构（如字典、集合和列表）的数据类型，可以通过将可哈希结构分配给名称与参数名称对应的属性来使这些对象“可缓存”。例如，接受查找值字典的数据类型可能会将其发布为一系列排序的 Tuples。给定一个以前不可缓存的类型为：

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'

通过将排序的 Tuples 元组分配给 “.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 版本的新Function： - 添加了 ExternalType mixin，它将 cache_ok 标志推广到 TypeDecorator 和 UserDefinedType 类。

另请参阅

SQL 编译缓存

方法 sqlalchemy.types.Interval 中。coerce_compared_value（op， value）¶

为表达式中的 'coerced' Python 值建议类型。

给定一个运算符和值，让类型有机会返回一个值应该被强制转换为的类型。

此处的默认行为是保守的;如果右侧已经根据其 Python 类型强制转换为 SQL 类型，则通常会单独保留它。

此处的最终用户功能扩展通常应通过 TypeDecorator 提供更自由的行为，因为它默认将表达式的另一端强制转换为此 type 类型，从而在这些 DBAPI 需要。它还提供了 public 方法 TypeDecorator.coerce_compared_value() 该 API 用于最终用户自定义此行为。

属性 sqlalchemy.types.Interval。comparator_factory¶: Comparator 的别名

属性 sqlalchemy.types.Interval。impl¶: DateTime 的别名

属性 sqlalchemy.types.Interval。python_type¶

方法 sqlalchemy.types.Interval 中。result_processor（dialect：方言， coltype： Any）→ _ResultProcessorType[dt.timedelta]¶

返回用于处理结果行值的转换函数。

返回一个可调用对象，该对象将接收结果行列值作为唯一的位置参数，并将返回一个值以返回给用户。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.result_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.result_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_result_value() .

另请参阅

扩充现有类型

参数

dialect¶– 正在使用的 Dialect 实例。
coltype¶– 在 cursor.description 中接收的 DBAPI coltype 参数。

类 sqlalchemy.types 中。LargeBinary¶

用于大型二进制字节数据的类型。

LargeBinary 类型对应于目标平台的大型和/或未加长的二进制类型，例如 MySQL 上的 BLOB 和 PostgreSQL 上的 BYTEA。它还处理 DBAPI 的必要转换。

成员

__init__（）

类签名

类 sqlalchemy.types.LargeBinary （sqlalchemy.types._Binary）

方法 sqlalchemy.types.LargeBinary 中。__init__（length：intNone=None）¶

构造 LargeBinary 类型。

参数: length¶ – 可选，用于 DDL 语句的列的长度，适用于接受长度的二进制类型，例如 MySQL BLOB 类型。

类 sqlalchemy.types 中。匹配类型¶

指 MATCH 运算符的返回类型。

由于 ColumnOperators.match（） 可能是通用 SQLAlchemy Core 中最开放的运算符，因此我们不能在 SQL 评估时假设返回类型，因为 MySQL 返回浮点而不是布尔值，并且其他后端可能会执行不同的作。所以这个类型充当占位符，当前是 Boolean 的子类化。该类型允许 dialects 在需要时注入结果处理功能，并在 MySQL 上返回浮点值。

类签名

类 sqlalchemy.types.MatchType （sqlalchemy.types.Boolean）

类 sqlalchemy.types 中。数值¶

非整数数值类型的 Base，例如 NUMERIC、FLOAT、DECIMAL 和其他变体。

直接使用 Numeric 数据类型时，将呈现 DDL 对应于精度数字（如果可用），例如 NUMERIC（精度，小数位数）的Float 子类将尝试呈现浮点数据类型，例如 FLOAT（precision）。

Numeric 返回 Python 十进制。Decimal 对象，基于 Numeric.asdecimal 参数。如果该参数设置为 False，则返回值将被强制转换为 Python 浮点对象。

Float 子类型更特定于浮点，将 Float.asdecimal 标志默认为 False，以便默认 Python 数据类型为 float。

注意

当对将 Python 浮点值返回给驱动程序的数据库类型使用 Numeric 数据类型时，Numeric.asdecimal 指示的十进制转换的准确性可能会受到限制。特定数字/浮点数据类型的行为是正在使用的 SQL 数据类型 Python DBAPI 的产物使用中，以及可能存在的策略正在使用的 SQLAlchemy 方言。需要特定精度的用户/ scale 鼓励尝试可用的数据类型以确定最佳结果。

成员

__init__（）、bind_processor（）、get_dbapi_type（）、literal_processor（）、python_type、result_processor（）

类签名

类 sqlalchemy.types.Numeric （ sqlalchemy.types.HasExpressionLookup ， sqlalchemy.types.TypeEngine）

方法 sqlalchemy.types.Numeric 中。__init__（precision：intNone=None， scale：intNone=None， decimal_return_scale：intNone=None， asdecimal： bool = True）¶

构造一个数值。

参数

precision¶- DDL CREATE 中使用的数值精度 TABLE 的
scale¶ – 在 DDL CREATE TABLE 中使用的数字比例。
asdecimal¶ – 默认为 True。返回值是否应作为 Python Decimal 对象或浮点数发送。不同的 DBAPI 根据数据类型发送一个或另一个 - Numeric 类型将确保 DBAPI 之间的返回值始终如一。
decimal_return_scale¶ – 转换时使用的默认比例从 floats 到 Python decimals。浮点值通常会由于十进制不准确，并且大多数浮点数数据库类型没有 “scale” 的概念，因此默认情况下， float 类型在转换时查找前十位小数。指定此值将覆盖该长度。类型务必包含显式的 “.scale” 值，例如基 numeric 以及 MySQL 浮点类型将使用 “.scale” 的值作为 decimal_return_scale 的默认值（如果未另行指定）。

使用 Numeric 类型时，应注意确保 asdecimal 设置适合正在使用的 DBAPI - 当 Numeric 应用从 Decimal->float 或 float-> Decimal 的转换时，此转换会为收到的所有结果列带来额外的性能开销。

本机返回 Decimal 的 DBAPI（例如 psycopg2）在设置为 True 时将具有更好的准确性和更高的性能，因为本机转换为 Decimal 减少了浮点问题的数量，并且 Numeric 类型本身不需要应用任何进一步的转换。但是，另一个本地返回浮点数的 DBAPI 将产生额外的转换开销，并且仍然会丢失浮点数据 - 在这种情况下，asdecimal=False 至少会消除额外的转换开销。

方法 sqlalchemy.types.Numeric 中。bind_processor（方言）¶

返回用于处理绑定值的转换函数。

返回一个可调用对象，该对象将接收一个 bind 参数值作为唯一的位置参数，并将返回一个值以发送到 DB-API。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.bind_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.bind_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_bind_param() .

另请参阅

扩充现有类型

参数: dialect¶– 正在使用的 Dialect 实例。

方法 sqlalchemy.types.Numeric 中。get_dbapi_type（dbapi）¶

从底层 DB-API 返回相应的类型对象（如果有）。

例如，这对于调用 setinputsizes（） 很有用。

方法 sqlalchemy.types.Numeric 中。literal_processor（方言）¶

返回一个转换函数，用于处理要直接呈现的文本值，而无需使用绑定。

当编译器使用 “literal_binds” 标志时，将使用此函数，该标志通常用于 DDL 生成以及后端不接受绑定参数的某些场景。

返回一个可调用对象，该对象将接收一个文字 Python 值作为唯一的位置参数，并将返回一个字符串表示形式，以便在 SQL 语句中呈现。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.literal_processor() 类而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.literal_processor() ，实现 TypeDecorator 类并提供 TypeDecorator.process_literal_param() .

另请参阅

扩充现有类型

属性 sqlalchemy.types.Numeric。python_type¶

方法 sqlalchemy.types.Numeric 中。result_processor（方言，同类型）¶

返回用于处理结果行值的转换函数。

返回一个可调用对象，该对象将接收结果行列值作为唯一的位置参数，并将返回一个值以返回给用户。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.result_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.result_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_result_value() .

另请参阅

扩充现有类型

参数

dialect¶– 正在使用的 Dialect 实例。
coltype¶– 在 cursor.description 中接收的 DBAPI coltype 参数。

类 sqlalchemy.types 中。PickleType¶

保存 Python 对象，这些对象使用 pickle 进行序列化。

PickleType 基于 Binary 类型构建，以应用 Python 的 pickle.dumps（） 传递给传入对象，并在传出时 pickle.loads（） ，允许将任何可 pickle的 Python 对象存储为序列化的二进制字段。

要允许 ORM 更改事件传播与 PickleType 关联的元素，请参阅更改跟踪。

成员

__init__（）、bind_processor（）、cache_ok、compare_values（）、impl、result_processor（）

类签名

类 sqlalchemy.types.PickleType （）（） sqlalchemy.types.TypeDecorator

方法 sqlalchemy.types.PickleType 中。__init__（protocol： int = 5， pickler： Any = None， comparator：Callable[[Any，Any]，bool]None=None， impl：_TypeEngineArgument[Any]None=无）¶

构造一个 PickleType。

参数

protocol¶ —— 默认为 pickle。HIGHEST_PROTOCOL。
pickler¶ —— 默认为 pickle。可以是具有 pickle 兼容 dumps 和 loads 方法的任何对象。
comparator¶—— 一个 2-arg 的可调用谓词，用于比较这种类型的值。如果保留为 None，则使用 Python “equals” 运算符来比较值。
impl¶ –

用于代替默认 LargeBinary 的二进制存储 TypeEngine 类或实例。例如：class： _mysql。LONGBLOB 类在使用 MySQL 时可能更有效。

在 1.4.20 版本加入.

方法 sqlalchemy.types.PickleType 中。bind_processor（方言）¶

为给定的 Dialect 提供绑定值处理函数。

这是实现 TypeEngine 的方法合约进行绑定值转换，通常通过 TypeEngine.bind_processor（） 方法。

注意

用户定义的 TypeDecorator 子类应该不实现此方法，而应该实现 TypeDecorator.process_bind_param() 以便维护 implementation 类型提供的 “inner” 处理。

参数: dialect¶– 正在使用的 Dialect 实例。

属性 sqlalchemy.types.PickleType 的 PickleType 中。cache_ok：boolNone = 真¶

指示使用此 ExternalType 的语句是否“可以安全缓存”。

默认值 None 将发出警告，然后不允许缓存包含此类型的语句。设置为 False 可完全禁止缓存使用此类型的语句，而不会显示警告。当设置为 True 时，对象的类和从其 state 将用作缓存键的一部分。例如，使用 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。

为了适应引用不可哈希结构（如字典、集合和列表）的数据类型，可以通过将可哈希结构分配给名称与参数名称对应的属性来使这些对象“可缓存”。例如，接受查找值字典的数据类型可能会将其发布为一系列排序的 Tuples。给定一个以前不可缓存的类型为：

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'

通过将排序的 Tuples 元组分配给 “.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 版本的新Function： - 添加了 ExternalType mixin，它将 cache_ok 标志推广到 TypeDecorator 和 UserDefinedType 类。

另请参阅

SQL 编译缓存

方法 sqlalchemy.types.PickleType 中。compare_values（x， y）¶

给定两个值，比较它们是否相等。

默认情况下，这会调用 TypeEngine.compare_values（） 底层的 “impl” 中，而使用 Python 等于运算符 ==。

ORM 使用此函数将原始加载的值与截获的 “更改” 值进行比较，以确定是否发生了净变化。

属性 sqlalchemy.types.PickleType 的 PickleType 中。impl¶: LargeBinary 的别名

方法 sqlalchemy.types.PickleType 中。result_processor（方言，同类型）¶

为给定的 方言。

这是实现 TypeEngine 的方法合约进行绑定值转换，通常通过 TypeEngine.result_processor（） 方法。

注意

用户定义的 TypeDecorator 子类应该不实现此方法，而应该实现 TypeDecorator.process_result_value() 以便维护 implementation 类型提供的 “inner” 处理。

参数

dialect¶– 正在使用的 Dialect 实例。
coltype¶ – SQLAlchemy 数据类型

类 sqlalchemy.types 中。SchemaType¶

向类型添加功能，以允许架构级 DDL 与类型相关联。

支持必须显式创建/删除的类型（即 PG ENUM 类型）以及由表或架构级别约束、触发器和其他规则补充的类型。

SchemaType 类也可以是 DDLEvents.before_parent_attach() 和 DDLEvents.after_parent_attach() 事件，事件触发的位置将 Type Object 与父级的关联括起来 列。

另请参阅

枚举

布尔

成员

adapt（）， copy（）， create（）， drop（）， name

类签名

类 sqlalchemy.types.SchemaType （ sqlalchemy.sql.expression.SchemaEventTarget ， sqlalchemy.types.TypeEngineMixin ）

方法 sqlalchemy.types.SchemaType 中。adapt（cls：Type[TypeEngineTypeEngineMixin]， **kw： Any）→ TypeEngine¶

方法 sqlalchemy.types.SchemaType 中。copy（**kw）¶

方法 sqlalchemy.types.SchemaType 中。create（bind， checkfirst=False）¶: 为此类型发出 CREATE DDL（如果适用）。

方法 sqlalchemy.types.SchemaType 中。drop（bind， checkfirst=False）¶: 为此类型发出 DROP DDL（如果适用）。

属性 sqlalchemy.types.SchemaType 的 SchemaType 中。name：strNone¶

类 sqlalchemy.types 中。SmallInteger 函数¶

用于较小 int 整数的类型。

通常在 DDL 中生成 SMALLINT，否则在 Python 端的行为类似于普通的 Integer。

类签名

类 sqlalchemy.types.SmallInteger （sqlalchemy.types.Integer）

类 sqlalchemy.types 中。字符串¶

所有字符串和字符类型的基数。

在 SQL 中，对应于 VARCHAR。

在 CREATE TABLE 语句中使用 String 类型时，通常需要 length 字段，因为 VARCHAR 在大多数数据库上都需要长度。

成员

__init__（）、bind_processor（）、get_dbapi_type（）、literal_processor（）、python_type、result_processor（）

类签名

类 sqlalchemy.types.String （sqlalchemy.types.Concatenable， sqlalchemy.types.TypeEngine）

方法 sqlalchemy.types.String 中。__init__（length：intNone=无， collation：strNone=无）¶

创建字符串保持类型。

参数

length¶ – 可选，用于 DDL 和 CAST 表达式的列的长度。如果没有 CREATE ，则可以安全地省略桌子将发布。某些数据库可能需要 length 在 DDL 中使用，如果 VARCHAR 不包括长度。值是否为解释为 bytes 或 characters 是特定于数据库的。
排序规则¶ –

可选，用于 DDL 和 CAST 表达式的列级排序规则。使用 SQLite、MySQL 和 PostgreSQL 支持的 COLLATE 关键字进行渲染。例如：
```
>>> 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
```
注意

在大多数情况下，Unicode 或 UnicodeText 数据类型应用于预期存储非 ASCII 数据的 Column。这些数据类型将确保在数据库上使用正确的类型。

方法 sqlalchemy.types.String 中。bind_processor（方言）¶

返回用于处理绑定值的转换函数。

返回一个可调用对象，该对象将接收一个 bind 参数值作为唯一的位置参数，并将返回一个值以发送到 DB-API。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.bind_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.bind_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_bind_param() .

另请参阅

扩充现有类型

参数: dialect¶– 正在使用的 Dialect 实例。

方法 sqlalchemy.types.String 中。get_dbapi_type（dbapi）¶

从底层 DB-API 返回相应的类型对象（如果有）。

例如，这对于调用 setinputsizes（） 很有用。

方法 sqlalchemy.types.String 中。literal_processor（方言）¶

返回一个转换函数，用于处理要直接呈现的文本值，而无需使用绑定。

当编译器使用 “literal_binds” 标志时，将使用此函数，该标志通常用于 DDL 生成以及后端不接受绑定参数的某些场景。

返回一个可调用对象，该对象将接收一个文字 Python 值作为唯一的位置参数，并将返回一个字符串表示形式，以便在 SQL 语句中呈现。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.literal_processor() 类而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.literal_processor() ，实现 TypeDecorator 类并提供 TypeDecorator.process_literal_param() .

另请参阅

扩充现有类型

属性 sqlalchemy.types.String 的 String。python_type¶

方法 sqlalchemy.types.String 中。result_processor（方言，同类型）¶

返回用于处理结果行值的转换函数。

返回一个可调用对象，该对象将接收结果行列值作为唯一的位置参数，并将返回一个值以返回给用户。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.result_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.result_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_result_value() .

另请参阅

扩充现有类型

参数

dialect¶– 正在使用的 Dialect 实例。
coltype¶– 在 cursor.description 中接收的 DBAPI coltype 参数。

类 sqlalchemy.types 中。文本¶

可变大小的字符串类型。

在 SQL 中，通常对应于 CLOB 或 TEXT。通常，TEXT 对象没有长度;虽然一些数据库会在这里接受 length 参数，但它会被其他数据库拒绝。

类签名

类 sqlalchemy.types.Text （sqlalchemy.types.String）

类 sqlalchemy.types 中。时间¶

datetime.time（） 对象的类型。

成员

get_dbapi_type（）、literal_processor（）python_type

类签名

类 sqlalchemy.types.Time （ sqlalchemy.types._RenderISO8601NoT ， sqlalchemy.types.HasExpressionLookup ， sqlalchemy.types.TypeEngine）

方法 sqlalchemy.types.Time 中。get_dbapi_type（dbapi）¶

从底层 DB-API 返回相应的类型对象（如果有）。

例如，这对于调用 setinputsizes（） 很有用。

方法 sqlalchemy.types.Time 中。literal_processor（方言）¶

返回一个转换函数，用于处理要直接呈现的文本值，而无需使用绑定。

当编译器使用 “literal_binds” 标志时，将使用此函数，该标志通常用于 DDL 生成以及后端不接受绑定参数的某些场景。

返回一个可调用对象，该对象将接收一个文字 Python 值作为唯一的位置参数，并将返回一个字符串表示形式，以便在 SQL 语句中呈现。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.literal_processor() 类而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.literal_processor() ，实现 TypeDecorator 类并提供 TypeDecorator.process_literal_param() .

另请参阅

扩充现有类型

属性 sqlalchemy.types.Time 的python_type¶

类 sqlalchemy.types 中。Unicode 代码¶

可变长度的 Unicode 字符串类型。

Unicode 类型是一个 String 子类，它假定可能包含非 ASCII 字符的输入和输出字符串，并且对于某些后端意味着显式支持非 ASCII 数据的基础列类型，例如 Oracle Database 和 SQL Server 上的 NVARCHAR。这将影响 CREATE TABLE 语句和 CAST 函数。

用于向数据库传输和接收数据的 Unicode 类型使用的字符编码通常由 DBAPI 本身确定。所有现代 DBAPI 都支持非 ASCII 字符串，但可能具有不同的数据库编码管理方法;如有必要，应按照 Dialects 部分中目标 DBAPI 的注释中的详细说明配置此编码。

在现代 SQLAlchemy 中，使用 Unicode 数据类型并不意味着 SQLAlchemy 本身内的任何编码/解码行为。在 Python 3 中，所有字符串对象本质上都支持 Unicode，并且 SQLAlchemy 不会生成字节字符串对象，也不会容纳不在字符串值的结果集中返回 Python Unicode 对象的 DBAPI。

警告

已知某些数据库后端（尤其是带有 pyodbc 的 SQL Server）对标记为 NVARCHAR 类型而不是 VARCHAR 的数据存在不良行为，包括数据类型不匹配错误和不使用索引。 DialectEvents.do_setinputsizes() 有关解决后端（如使用 pyodbc 的 SQL Server）的 unicode 字符问题的背景信息，请参阅 cx_Oracle 部分。

另请参阅

UnicodeText - Unicode 的未加长文本对应物。

DialectEvents.do_setinputsizes()

类签名

类 sqlalchemy.types.Unicode （sqlalchemy.types.String）

类 sqlalchemy.types 中。UnicodeText¶

无限长度的 Unicode 字符串类型。

有关此对象的 unicode 行为的详细信息，请参阅 Unicode。

与 Unicode 一样，使用 UnicodeText 类型意味着支持 Unicode 的类型，例如 NCLOB的，NTEXT的。

类签名

类 sqlalchemy.types.UnicodeText （sqlalchemy.types.Text）

类 sqlalchemy.types 中。uuid 的¶

表示与数据库无关的 UUID 数据类型。

对于没有“本机”UUID 数据类型的后端，该值将使用 CHAR（32） 并将 UUID 存储为 32 个字符的字母数字十六进制字符串。

对于已知直接支持 UUID 或类似的 UUID 存储数据类型（如 SQL Server 的 UNIQUEIDENTIFIER）的后端，默认情况下启用的“本机”模式允许在这些后端使用这些类型。

在其默认使用模式下，Uuid 数据类型需要 Python uuid 对象，来自 Python uuid 模块：

import uuid

from sqlalchemy import Uuid
from sqlalchemy import Table, Column, MetaData, String


metadata_obj = MetaData()

t = Table(
    "t",
    metadata_obj,
    Column("uuid_data", Uuid, primary_key=True),
    Column("other_data", String),
)

with engine.begin() as conn:
    conn.execute(
        t.insert(), {"uuid_data": uuid.uuid4(), "other_data": "some data"}
    )

让 Uuid 数据类型使用基于字符串的 Uuid（例如 32 个字符的十六进制字符串）传递 Uuid.as_uuid值为 False 的参数。

2.0 版的新Function。

另请参阅

UUID - 准确表示 UUID 数据类型，没有任何与后端无关的行为。

成员

__init__（）、bind_processor（）、coerce_compared_value（）、literal_processor（）、python_type、result_processor（）

类签名

类 sqlalchemy.types.Uuid （sqlalchemy.types.Emulated， sqlalchemy.types.TypeEngine）

方法 sqlalchemy.types.Uuid 中。__init__（as_uuid： bool = True， native_uuid： bool = True）¶

构造 Uuid 类型。

参数

as_uuid=真¶ –

如果为 True，则值将被解释为 Python uuid 对象，通过 DBAPI 与字符串相互转换。
native_uuid=True¶ – 如果为 True，则支持 UUID 数据类型，或者 UUID 存储值（例如 SQL Server 的 UNIQUEIDENTIFIER）将由这些后端使用。如果为 False，则 CHAR（32） 数据类型将用于所有后端，而不管本机支持如何。

方法 sqlalchemy.types.Uuid 中。bind_processor（方言）¶

返回用于处理绑定值的转换函数。

返回一个可调用对象，该对象将接收一个 bind 参数值作为唯一的位置参数，并将返回一个值以发送到 DB-API。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.bind_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.bind_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_bind_param() .

另请参阅

扩充现有类型

参数: dialect¶– 正在使用的 Dialect 实例。

方法 sqlalchemy.types.Uuid 中。coerce_compared_value（op， value）¶: 有关说明，请参阅 TypeEngine.coerce_compared_value() 。

方法 sqlalchemy.types.Uuid 中。literal_processor（方言）¶

返回一个转换函数，用于处理要直接呈现的文本值，而无需使用绑定。

当编译器使用 “literal_binds” 标志时，将使用此函数，该标志通常用于 DDL 生成以及后端不接受绑定参数的某些场景。

返回一个可调用对象，该对象将接收一个文字 Python 值作为唯一的位置参数，并将返回一个字符串表示形式，以便在 SQL 语句中呈现。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.literal_processor() 类而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.literal_processor() ，实现 TypeDecorator 类并提供 TypeDecorator.process_literal_param() .

另请参阅

扩充现有类型

属性 sqlalchemy.types.Uuid 的python_type¶

方法 sqlalchemy.types.Uuid 中。result_processor（方言，同类型）¶

返回用于处理结果行值的转换函数。

返回一个可调用对象，该对象将接收结果行列值作为唯一的位置参数，并将返回一个值以返回给用户。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.result_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.result_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_result_value() .

另请参阅

扩充现有类型

参数

dialect¶– 正在使用的 Dialect 实例。
coltype¶– 在 cursor.description 中接收的 DBAPI coltype 参数。

SQL 标准和多供应商 “UPPERCASE” 类型¶

这类类型是指属于 SQL 标准的一部分，或者可能在数据库后端子集中找到的类型。与“泛型”类型不同，SQL 标准/多供应商类型没有保证在所有后端工作，并且只能在这些后端工作，它们按名称明确支持它们。也就是说，该类型将始终发出它在 DDL 中使用 CREATE TABLE 的确切名称发出。

对象名称	描述
ARRAY	表示 SQL Array 类型。
BIGINT	SQL BIGINT 类型。
BINARY	SQL BINARY 类型。
BLOB	SQL BLOB 类型。
BOOLEAN	SQL BOOLEAN 类型。
CHAR	SQL CHAR 类型。
CLOB	CLOB 类型。
DATE	SQL DATE 类型。
DATETIME	SQL DATETIME 类型。
DECIMAL	SQL DECIMAL 类型。
DOUBLE	SQL DOUBLE 类型。
DOUBLE_PRECISION	SQL DOUBLE PRECISION 类型。
FLOAT	SQL FLOAT 类型。
INT	`INTEGER` 的别名
INTEGER	SQL INT 或 INTEGER 类型。
JSON	表示 SQL JSON 类型。
NCHAR	SQL NCHAR 类型。
NUMERIC	SQL NUMERIC 类型。
NVARCHAR	SQL NVARCHAR 类型。
REAL	SQL REAL 类型。
SMALLINT	SQL SMALLINT 类型。
TEXT	SQL TEXT 类型。
TIME	SQL TIME 类型。
TIMESTAMP	SQL TIMESTAMP 类型。
UUID	表示 SQL UUID 类型。
VARBINARY	SQL VARBINARY 类型。
VARCHAR	SQL VARCHAR 类型。

类 sqlalchemy.types 中。数组¶

表示 SQL Array 类型。

注意

此类型用作所有 ARRAY作的基础。但是，目前只有 PostgreSQL 后端支持 SQL 数组。建议使用 PostgreSQL 特定的 sqlalchemy.dialects.postgresql.ARRAY type 直接使用 ARRAY 类型，因为它提供了特定于该后端的其他运算符。

ARRAY 是 Core 的一部分，支持各种 SQL 标准函数，例如 array_agg 明确涉及阵列;但是，除了 PostgreSQL 后端和可能的部分第三方方言，其他 SQLAlchemy 内置方言均不支持对于此类型。

在给定元素的 “type” 的情况下构造 ARRAY 类型：

mytable = Table("mytable", metadata, Column("data", ARRAY(Integer)))

上述类型表示 N 维数组，这意味着 PostgreSQL 等支持后端将自动解释任意维度数的值。要生成传入一维整数数组的 INSERT 构造，请执行以下作：

connection.execute(mytable.insert(), {"data": [1, 2, 3]})

ARRAY 类型可以构造给定固定数量的维度：

mytable = Table(
    "mytable", metadata, Column("data", ARRAY(Integer, dimensions=2))
)

发送多个维度是可选的，但如果数据类型要表示多个维度的数组，则建议使用。此数字用于：

当向数据库发出类型声明本身时，例如 整数[][]
在将 Python 值转换为数据库值时，反之亦然，例如，Unicode 对象的 ARRAY 使用此数字来有效地访问数组结构内的字符串值，而无需求助于每行类型检查
当与 Python getitem 访问器一起使用时，维数用于定义 [] 运算符应返回的类型类型，例如，对于具有两个维度的 INTEGER ARRAY：
```
>>> expr = table.c.column[5]  # returns ARRAY(Integer, dimensions=1)
>>> expr = expr[6]  # returns Integer
```

对于一维数组，没有 dimension 参数的 ARRAY 实例通常会采用一维行为。

ARRAY 类型的 SQL 表达式支持 “index” 和 “slice” 行为。[] 运算符生成表达式构造，该构造将生成相应的 SQL，两者都适用于 SELECT 语句：

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]}
)

默认情况下，索引访问从 1 开始;对于从 0 开始的索引转换，请设置 ARRAY.zero_indexes。

ARRAY 类型还提供了运算符 Comparator.any（） 和 Comparator.all（） 中。特定于 PostgreSQL 的版本 ARRAY 还提供了其他运算符。

使用 ORM 时检测 ARRAY 列中的更改

ARRAY 类型与 SQLAlchemy ORM 一起使用时，不会检测数组的就地更改。为了检测这些，必须使用 sqlalchemy.ext.mutable 扩展，使用 MutableList 类：

from sqlalchemy import ARRAY
from sqlalchemy.ext.mutable import MutableList


class SomeOrmClass(Base):
    # ...

    data = Column(MutableList.as_mutable(ARRAY(Integer)))

此扩展将允许对数组进行“就地”更改，例如 .append（） 以生成工作单元将检测到的事件。请注意，不会检测到对数组内元素的更改，包括就地更改的子数组。

或者，将新的数组值分配给替换旧 ORM 元素的 ORM 元素将始终触发 change 事件。

另请参阅

sqlalchemy.dialects.postgresql.ARRAY

成员

__init__（）， contains（）， any（）， all（）

类签名

类 sqlalchemy.types.ARRAY （ sqlalchemy.sql.expression.SchemaEventTarget ， sqlalchemy.types.Indexable， sqlalchemy.types.Concatenable， sqlalchemy.types.TypeEngine）

方法 sqlalchemy.types.ARRAY。__init__（item_type： _TypeEngineArgument[Any]， as_tuple： bool = False， dimensions：intNone=None， zero_indexes： bool = False）¶

构造一个 ARRAY。

例如：

Column("myarray", ARRAY(Integer))

参数是：

参数

item_type¶- 此数组的 items 的数据类型。请注意，维数在这里无关紧要，因此像 INTEGER[][] 构造为 ARRAY（Integer），而不是 ARRAY（ARRAY（Integer）） 等。
as_tuple=False¶- 指定是否应将返回结果转换为列表中的元组。通常不需要此参数，因为 Python 列表与 SQL 数组非常对应。
dimensions¶ —— 如果非 None，则 ARRAY 将采用固定的维度数。这会影响数组的声明方式在数据库上，它如何解释 Python 和 result 值，以及表达式行为如何结合使用 “getItem” 运算符有效。请参阅以下位置的描述 ARRAY 了解更多详细信息。
zero_indexes=False¶ – 当为 True 时，索引值将在 Python 基于 0 的索引和 SQL 1 的索引之间转换，例如，在传递给数据库之前，将值 1 添加到所有索引值中。

类 Comparator¶

定义 ARRAY 的比较作。

此类型的特定于方言的形式上提供了更多运算符。参见 Comparator。

类签名

类 sqlalchemy.types.ARRAY.Comparator （sqlalchemy.types.Comparator， sqlalchemy.types.Comparator）

method sqlalchemy.types.ARRAY.Comparator. contains（*arg， **kw）¶: ARRAY.contains（） 未为基本 ARRAY 类型实现。使用特定于方言的 ARRAY 类型。

另请参阅

ARRAY - PostgreSQL 特定版本。

method sqlalchemy.types.ARRAY.Comparator. any（other， operator=None）¶

返回其他运算符 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))
)

参数

other¶ – 要比较的表达式
operator¶ —— 来自 sqlalchemy.sql.operators package 的 Package，默认为 eq（）。

另请参阅

any_（）

比较器.all（）

method sqlalchemy.types.ARRAY.Comparator. all（other， operator=None）¶

返回其他运算符 ALL （array） 子句。

旧版功能

此方法是特定于 ARRAY 的构造，现在已被 all_（） 取代函数，该函数具有不同的调用样式。这 all_（） 函数也通过 ColumnOperators.all_（） 方法在方法级别进行镜像。

使用特定于数组的 Comparator.all（） 如下：

from sqlalchemy.sql import operators

conn.execute(
    select(table.c.data).where(table.c.data.all(7, operator=operators.lt))
)

参数

other¶ – 要比较的表达式
operator¶ —— 来自 sqlalchemy.sql.operators package 的 Package，默认为 eq（）。

另请参阅

all_（）

比较器.any（）

类 sqlalchemy.types 中。BIGINT 的¶: SQL BIGINT 类型。

另请参阅

BigInteger - 基本类型的文档。

类签名

类 sqlalchemy.types.BIGINT （sqlalchemy.types.BigInteger）

类 sqlalchemy.types 中。二进制¶: SQL BINARY 类型。

类签名

类 sqlalchemy.types.BINARY （sqlalchemy.types._Binary）

类 sqlalchemy.types 中。BLOB 的¶

SQL BLOB 类型。

成员

__init__（）

类签名

类 sqlalchemy.types.BLOB （sqlalchemy.types.LargeBinary）

方法 sqlalchemy.types.BLOB 中。__init__（length：intNone=None）¶

继承自 sqlalchemy.types.LargeBinary.__init__ LargeBinary 的方法

构造 LargeBinary 类型。

参数: length¶ – 可选，用于 DDL 语句的列的长度，适用于接受长度的二进制类型，例如 MySQL BLOB 类型。

类 sqlalchemy.types 中。布尔值¶

SQL BOOLEAN 类型。

成员

__init__（）

类签名

类 sqlalchemy.types.BOOLEAN （sqlalchemy.types.Boolean）

方法 sqlalchemy.types.BOOLEAN 中。__init__（create_constraint： bool = False， name：strNone=None， _create_events： bool = True， _adapted_from：SchemaTypeNone=None）¶

继承自 sqlalchemy.types.Boolean.__init__ Boolean 的方法

构造一个布尔值。

参数

create_constraint¶ –

默认为 False。如果布尔值生成为 int/smallint，则还要在表上创建一个 CHECK 约束，以确保值为 1 或 0。

注意

强烈建议将 CHECK 约束具有显式名称，以便支持 Schema-Management 关注。这可以通过设置 Boolean.name 参数中，或者通过设置适当的命名约定;看为背景配置 Constraint Naming Conventions。

在 1.4 版本发生变更： - 此标志现在默认为 False，这意味着不会为非本机枚举类型生成 CHECK 约束。
name¶– 如果生成了 CHECK 约束，请指定约束的名称。

类 sqlalchemy.types 中。字符¶

SQL CHAR 类型。

成员

__init__（）

类签名

类 sqlalchemy.types.CHAR （sqlalchemy.types.String）

方法 sqlalchemy.types.CHAR 中。__init__（length：intNone=无， collation：strNone=无）¶

继承自 sqlalchemy.types.String.__init__ String 的方法

创建字符串保持类型。

参数

length¶ – 可选，用于 DDL 和 CAST 表达式的列的长度。如果没有 CREATE ，则可以安全地省略桌子将发布。某些数据库可能需要 length 在 DDL 中使用，如果 VARCHAR 不包括长度。值是否为解释为 bytes 或 characters 是特定于数据库的。
排序规则¶ –

可选，用于 DDL 和 CAST 表达式的列级排序规则。使用 SQLite、MySQL 和 PostgreSQL 支持的 COLLATE 关键字进行渲染。例如：
```
>>> 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
```
注意

在大多数情况下，Unicode 或 UnicodeText 数据类型应用于预期存储非 ASCII 数据的 Column。这些数据类型将确保在数据库上使用正确的类型。

类 sqlalchemy.types 中。CLOB 的¶

CLOB 类型。

此类型可在 Oracle Database 和 Informix 中找到。

成员

__init__（）

类签名

类 sqlalchemy.types.CLOB （sqlalchemy.types.Text）

方法 sqlalchemy.types.CLOB 中。__init__（length：intNone=无， collation：strNone=无）¶

继承自 sqlalchemy.types.String.__init__ String 的方法

创建字符串保持类型。

参数

length¶ – 可选，用于 DDL 和 CAST 表达式的列的长度。如果没有 CREATE ，则可以安全地省略桌子将发布。某些数据库可能需要 length 在 DDL 中使用，如果 VARCHAR 不包括长度。值是否为解释为 bytes 或 characters 是特定于数据库的。
排序规则¶ –

可选，用于 DDL 和 CAST 表达式的列级排序规则。使用 SQLite、MySQL 和 PostgreSQL 支持的 COLLATE 关键字进行渲染。例如：
```
>>> 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
```
注意

在大多数情况下，Unicode 或 UnicodeText 数据类型应用于预期存储非 ASCII 数据的 Column。这些数据类型将确保在数据库上使用正确的类型。

类 sqlalchemy.types 中。日期¶: SQL DATE 类型。

类签名

类 sqlalchemy.types.DATE （sqlalchemy.types.Date）

类 sqlalchemy.types 中。日期时间¶

SQL DATETIME 类型。

成员

__init__（）

类签名

类 sqlalchemy.types.DATETIME （sqlalchemy.types.DateTime）

方法 sqlalchemy.types.DATETIME 中。__init__（时区： bool = False）¶

继承自 sqlalchemy.types.DateTime.__init__ DateTime 的方法

构造新的 DateTime。

参数: timezone¶ – 布尔值。指示 datetime 类型应启用 Timezone Support（如果 仅限基准日期/时间持有类型。建议在使用此标志时直接使用 TIMESTAMP 数据类型，因为某些数据库包含与支持时区的 TIMESTAMP 数据类型不同的单独通用日期/时间保持类型，例如 Oracle Database。

类 sqlalchemy.types 中。十进制¶

SQL DECIMAL 类型。

另请参阅

Numeric - 基本类型的文档。

成员

__init__（）

类签名

类 sqlalchemy.types.DECIMAL （sqlalchemy.types.Numeric）

方法 sqlalchemy.types.DECIMAL 中。__init__（precision：intNone=None， scale：intNone=None， decimal_return_scale：intNone=None， asdecimal： bool = True）¶

继承自 sqlalchemy.types.Numeric.__init__ Numeric 的方法

构造一个数值。

参数

precision¶- DDL CREATE 中使用的数值精度 TABLE 的
scale¶ – 在 DDL CREATE TABLE 中使用的数字比例。
asdecimal¶ – 默认为 True。返回值是否应作为 Python Decimal 对象或浮点数发送。不同的 DBAPI 根据数据类型发送一个或另一个 - Numeric 类型将确保 DBAPI 之间的返回值始终如一。
decimal_return_scale¶ – 转换时使用的默认比例从 floats 到 Python decimals。浮点值通常会由于十进制不准确，并且大多数浮点数数据库类型没有 “scale” 的概念，因此默认情况下， float 类型在转换时查找前十位小数。指定此值将覆盖该长度。类型务必包含显式的 “.scale” 值，例如基 numeric 以及 MySQL 浮点类型将使用 “.scale” 的值作为 decimal_return_scale 的默认值（如果未另行指定）。

使用 Numeric 类型时，应注意确保 asdecimal 设置适合正在使用的 DBAPI - 当 Numeric 应用从 Decimal->float 或 float-> Decimal 的转换时，此转换会为收到的所有结果列带来额外的性能开销。

本机返回 Decimal 的 DBAPI（例如 psycopg2）在设置为 True 时将具有更好的准确性和更高的性能，因为本机转换为 Decimal 减少了浮点问题的数量，并且 Numeric 类型本身不需要应用任何进一步的转换。但是，另一个本地返回浮点数的 DBAPI 将产生额外的转换开销，并且仍然会丢失浮点数据 - 在这种情况下，asdecimal=False 至少会消除额外的转换开销。

类 sqlalchemy.types 中。双精度¶

SQL DOUBLE 类型。

2.0 版的新Function。

另请参阅

Double - 基本类型的文档。

成员

__init__（）

类签名

类 sqlalchemy.types.DOUBLE （sqlalchemy.types.Double）

方法 sqlalchemy.types.DOUBLE。__init__（precision：intNone=None， asdecimal： bool = False， decimal_return_scale：intNone=None）¶

继承自 sqlalchemy.types.Float.__init__ Float 的方法

构造一个浮点数。

参数

精度¶ –

在 DDL CREATE 中使用的数值精度TABLE 的后端应尝试确保此精度表示泛型 Float 数据类型。
注意

对于 Oracle Database 后端，渲染 DDL 时不接受 Float.precision 参数，因为 Oracle Database 不支持指定为小数位数的浮点精度。相反，请使用特定于 Oracle Database 的 FLOAT 数据类型并指定 FLOAT.binary_precision 参数。这是 SQLAlchemy 版本 2.0 中的新增功能。

要创建与数据库无关的 Float，请执行单独指定 Oracle Database 的二进制精度，请使用 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 小数时使用的默认比例。由于十进制的不准确，浮点值通常会长得多，并且大多数浮点数据库类型没有“小数位数”的概念，因此默认情况下，浮点类型在转换时查找前十位小数。指定此值将覆盖该长度。请注意，如果未另行指定，则包含 “scale” 的 MySQL 浮点类型将使用 “scale” 作为 decimal_return_scale 的默认值。

类 sqlalchemy.types 中。DOUBLE_PRECISION¶

SQL DOUBLE PRECISION 类型。

2.0 版的新Function。

另请参阅

Double - 基本类型的文档。

成员

__init__（）

类签名

类 sqlalchemy.types.DOUBLE_PRECISION （sqlalchemy.types.Double）

方法 sqlalchemy.types.DOUBLE_PRECISION. __init__（precision：intNone=None， asdecimal： bool = False， decimal_return_scale：intNone=None）¶

继承自 sqlalchemy.types.Float.__init__ Float 的方法

构造一个浮点数。

参数

精度¶ –

在 DDL CREATE 中使用的数值精度TABLE 的后端应尝试确保此精度表示泛型 Float 数据类型。
注意

对于 Oracle Database 后端，渲染 DDL 时不接受 Float.precision 参数，因为 Oracle Database 不支持指定为小数位数的浮点精度。相反，请使用特定于 Oracle Database 的 FLOAT 数据类型并指定 FLOAT.binary_precision 参数。这是 SQLAlchemy 版本 2.0 中的新增功能。

要创建与数据库无关的 Float，请执行单独指定 Oracle Database 的二进制精度，请使用 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 小数时使用的默认比例。由于十进制的不准确，浮点值通常会长得多，并且大多数浮点数据库类型没有“小数位数”的概念，因此默认情况下，浮点类型在转换时查找前十位小数。指定此值将覆盖该长度。请注意，如果未另行指定，则包含 “scale” 的 MySQL 浮点类型将使用 “scale” 作为 decimal_return_scale 的默认值。

类 sqlalchemy.types 中。浮点数（FLOAT）¶

SQL FLOAT 类型。

另请参阅

Float - 基本类型的文档。

成员

__init__（）

类签名

类 sqlalchemy.types.FLOAT （sqlalchemy.types.Float）

方法 sqlalchemy.types.FLOAT 中。__init__（precision：intNone=None， asdecimal： bool = False， decimal_return_scale：intNone=None）¶

继承自 sqlalchemy.types.Float.__init__ Float 的方法

构造一个浮点数。

参数

精度¶ –

在 DDL CREATE 中使用的数值精度TABLE 的后端应尝试确保此精度表示泛型 Float 数据类型。
注意

对于 Oracle Database 后端，渲染 DDL 时不接受 Float.precision 参数，因为 Oracle Database 不支持指定为小数位数的浮点精度。相反，请使用特定于 Oracle Database 的 FLOAT 数据类型并指定 FLOAT.binary_precision 参数。这是 SQLAlchemy 版本 2.0 中的新增功能。

要创建与数据库无关的 Float，请执行单独指定 Oracle Database 的二进制精度，请使用 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 小数时使用的默认比例。由于十进制的不准确，浮点值通常会长得多，并且大多数浮点数据库类型没有“小数位数”的概念，因此默认情况下，浮点类型在转换时查找前十位小数。指定此值将覆盖该长度。请注意，如果未另行指定，则包含 “scale” 的 MySQL 浮点类型将使用 “scale” 作为 decimal_return_scale 的默认值。

属性 sqlalchemy.types..sqlalchemy.types 中。INT 函数¶: INTEGER 的别名

类 sqlalchemy.types 中。JSON格式¶

表示 SQL JSON 类型。

注意

JSON 格式作为供应商特定 JSON 类型。由于它支持 JSON SQL作，因此它只适用于具有实际 JSON 类型的后端，目前：

PostgreSQL - 请参阅 sqlalchemy.dialects.postgresql.JSON 和 sqlalchemy.dialects.postgresql.JSONB 对于特定于后端的注释
MySQL - 请参阅 sqlalchemy.dialects.mysql.JSON 对于特定于后端的注释
SQLite 3.9 及以上版本 - 请参阅 sqlalchemy.dialects.sqlite.JSON 对于特定于后端的注释
Microsoft SQL Server 2016 及更高版本 - 请参阅 sqlalchemy.dialects.mssql.JSON 对于特定于后端的注释

JSON 是 Core 的一部分，支持原生 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 的表达式运算符

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（） - 以整数形式返回元素

这些数据转换程序是通过支持 dialect 实现的，以确保与上述类型的比较能够按预期工作，例如：

# integer comparison
data_table.c.data["some_integer_key"].as_integer() == 5

# boolean comparison
data_table.c.data["some_boolean"].as_boolean() == True

1.3.11 版本中的新功能：为基本 JSON 数据元素类型添加了特定于类型的铸造者。

注意

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 扩展，最常见的是使用 MutableDict 类。此扩展将允许对数据结构进行“就地”更改，以生成将由工作单元检测到的事件。请参阅 HSTORE 上的示例有关涉及字典的简单示例。

或者，将 JSON 结构分配给替换旧元素的 ORM 元素将始终触发 change 事件。

支持 JSON null vs. SQL NULL

使用 NULL 值时，JSON 类型建议使用使用两个特定常量来区分列的计算结果为 SQL NULL，例如无值，而不是 JSON 编码的字符串 “null” 的要插入或选择为 SQL NULL 的值，请使用常量 null（）。使用 JSON 数据类型时，此符号可以作为参数值传递，其中包含特殊逻辑，该逻辑将此符号解释为表示列值应为 SQL NULL 而不是 JSON “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 的 JSON 格式。NULL 和 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 重命名的 parameters 和 _json_deserializer。

另请参阅

sqlalchemy.dialects.postgresql.JSON

sqlalchemy.dialects.postgresql.JSONB

sqlalchemy.dialects.mysql.JSON

sqlalchemy.dialects.sqlite.JSON

成员

as_boolean（）， as_float（）， as_integer（）， as_json（）， as_numeric（）， as_string（）， bind_processor（）， literal_processor（）， NULL， __init__（）， bind_processor（）， comparator_factory，可哈希， python_type、result_processor（） should_evaluate_none

类签名

类 sqlalchemy.types.JSON （sqlalchemy.types.Indexable， sqlalchemy.types.TypeEngine）

类 Comparator¶

定义 JSON 的比较作。

类签名

类 sqlalchemy.types.JSON.Comparator （sqlalchemy.types.Comparator， sqlalchemy.types.Comparator）

方法 sqlalchemy.types.JSON.Comparator. as_boolean（）¶

将索引值视为布尔值。

这类似于使用 type_coerce，通常不会应用 CAST（）。

例如：

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（）¶

将索引值视为 float。

这类似于使用 type_coerce，通常不会应用 CAST（）。

例如：

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（）¶

将索引值视为整数。

这类似于使用 type_coerce，通常不会应用 CAST（）。

例如：

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。

这类似于使用 type_coerce，通常不会应用 CAST（）。

例如：

stmt = select(mytable.c.json_column["some_data"].as_json())

在任何情况下，这通常是索引元素的默认行为。

请注意，并非所有后端都支持完整 JSON 结构的比较。

在 1.3.11 版本加入.

方法 sqlalchemy.types.JSON.Comparator. as_numeric（precision， scale， asdecimal=True）¶

将索引值视为 numeric/decimal。

这类似于使用 type_coerce，通常不会应用 CAST（）。

例如：

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 版本的新Function。

方法 sqlalchemy.types.JSON.Comparator. as_string（）¶

将索引值视为 string。

这类似于使用 type_coerce，通常不会应用 CAST（）。

例如：

stmt = select(mytable.c.json_column["some_data"].as_string()).where(
    mytable.c.json_column["some_data"].as_string() == "some string"
)

在 1.3.11 版本加入.

类 JSONElementType¶

JSON 表达式中索引/路径元素的通用函数。

类签名

类 sqlalchemy.types.JSON.JSONElementType （sqlalchemy.types.TypeEngine）

方法 sqlalchemy.types.JSON.JSONElementType. bind_processor（方言）¶

返回用于处理绑定值的转换函数。

返回一个可调用对象，该对象将接收一个 bind 参数值作为唯一的位置参数，并将返回一个值以发送到 DB-API。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.bind_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.bind_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_bind_param() .

另请参阅

扩充现有类型

参数: dialect¶– 正在使用的 Dialect 实例。

方法 sqlalchemy.types.JSON.JSONElementType. literal_processor（方言）¶

返回一个转换函数，用于处理要直接呈现的文本值，而无需使用绑定。

当编译器使用 “literal_binds” 标志时，将使用此函数，该标志通常用于 DDL 生成以及后端不接受绑定参数的某些场景。

返回一个可调用对象，该对象将接收一个文字 Python 值作为唯一的位置参数，并将返回一个字符串表示形式，以便在 SQL 语句中呈现。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.literal_processor() 类而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.literal_processor() ，实现 TypeDecorator 类并提供 TypeDecorator.process_literal_param() .

另请参阅

扩充现有类型

类 JSONIndexType¶

JSON 索引值的数据类型的占位符。

这允许对特殊语法的 JSON 索引值进行执行时处理。

类签名

类 sqlalchemy.types.JSON.JSONIndexType （ sqlalchemy.types.JSONElementType ）

类 JSONIntIndexType¶

JSON 索引值的数据类型的占位符。

这允许对特殊语法的 JSON 索引值进行执行时处理。

类签名

类 sqlalchemy.types.JSON.JSONIntIndexType （ sqlalchemy.types.JSONIndexType ）

类 JSONPathType¶

JSON 路径作的占位符类型。

这允许在执行时将基于路径的索引值处理为特定的 SQL 语法。

类签名

类 sqlalchemy.types.JSON.JSONPathType （ sqlalchemy.types.JSONElementType ）

类 JSONStrIndexType¶

JSON 索引值的数据类型的占位符。

这允许对特殊语法的 JSON 索引值进行执行时处理。

类签名

类 sqlalchemy.types.JSON.JSONStrIndexType （ sqlalchemy.types.JSONIndexType ）

属性sqlalchemy.types.JSON。 NULL = symbol（'JSON_NULL'）¶

描述 NULL 的 json 值。

此值用于强制将 JSON 值 “null” 用作值。根据 Python None 标志的设置，该值 Python None 将被识别为 SQL NULL 或 JSON “null”JSON.none_as_null ;这 JSON 的 JSON 格式。零 constant 可用于始终解析为 JSON “null”，而不管此设置如何。这与 null（） 形成对比构建它始终解析为 SQL NULL。例如：

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 的 JSON 格式。NULL 值将作为列的值返回，这在 ORM 或其他默认值的重新利用上下文中可能并不可取。使用 SQL 表达式意味着将在检索生成的默认值的上下文中从数据库中重新获取该值。

方法 sqlalchemy.types.JSON。__init__（none_as_null： bool = False）¶

构造 JSON 类型。

参数

none_as_null=假¶ –

如果为 True，则将值 None 保留为 SQL NULL 值，而不是 null 的 JSON 编码。请注意，当此标志为 False 时，null（） 构造仍可用于保留 NULL 值，该值可以直接作为参数值传递，该参数值由 JSON 类型专门解释为 SQL NULL：

from sqlalchemy import null

conn.execute(table.insert(), {"data": null()})

注意

JSON.none_as_null 不适用于传递给 Column.default 和 Column.server_default;值为 None 为这些参数传递的表示 “No default present”。

此外，在 SQL 比较表达式中使用时，Python 值 None 继续引用 SQL null，而不是 JSON NULL。JSON.none_as_null 标志显式引用 INSERT 或 UPDATE 语句中值的持久性。JSON.零 value 应用于希望比较的 SQL 表达式 JSON null 的 JSON null。

另请参阅

JSON 的 JSON 格式。零

方法 sqlalchemy.types.JSON。bind_processor（方言）¶

返回用于处理绑定值的转换函数。

返回一个可调用对象，该对象将接收一个 bind 参数值作为唯一的位置参数，并将返回一个值以发送到 DB-API。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.bind_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.bind_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_bind_param() .

另请参阅

扩充现有类型

参数: dialect¶– 正在使用的 Dialect 实例。

属性sqlalchemy.types.JSON。comparator_factory¶: Comparator 的别名

属性sqlalchemy.types.JSON。hashable = 假¶

Flag（如果为 False），则表示此类型的值不可哈希。

由 ORM 在显示结果列表时使用。

属性sqlalchemy.types.JSON。python_type¶

方法 sqlalchemy.types.JSON。result_processor（方言，同类型）¶

返回用于处理结果行值的转换函数。

返回一个可调用对象，该对象将接收结果行列值作为唯一的位置参数，并将返回一个值以返回给用户。

如果不需要处理，该方法应返回 None。

注意

此方法仅相对于 dialect 特定类型调用 object，它通常是正在使用的方言私有的，并且与面向公众的对象不是同一类型对象，这意味着为了提供替代 TypeEngine.result_processor（） 而将 TypeEngine 类子类化是不可行的方法，除非将 UserDefinedType 子类化类。

要为 TypeEngine.result_processor（）中，实现 TypeDecorator 类并提供 TypeDecorator.process_result_value() .

另请参阅

扩充现有类型

参数

dialect¶– 正在使用的 Dialect 实例。
coltype¶– 在 cursor.description 中接收的 DBAPI coltype 参数。

属性sqlalchemy.types.JSON。should_evaluate_none： bool¶

如果为 True，则 Python 常量 None 被视为由此类型显式处理。

ORM 使用此标志来指示 None 的正值在 INSERT 语句中传递给列，而不是省略来自 INSERT 语句的列，该列具有触发的效果 off 列级默认值。它还允许具有特殊行为（例如 JSON 类型），以指示他们希望显式处理 None 值。

要在现有类型上设置此标志，请使用 TypeEngine.evaluates_none（） 方法。

另请参阅

TypeEngine.evaluates_none（）

类 sqlalchemy.types 中。整数¶: SQL INT 或 INTEGER 类型。

另请参阅

Integer - 基本类型的文档。

类签名

类 sqlalchemy.types.INTEGER （sqlalchemy.types.Integer）

类 sqlalchemy.types 中。NCHAR的¶

SQL NCHAR 类型。

成员

__init__（）

类签名

类 sqlalchemy.types.NCHAR （sqlalchemy.types.Unicode）

方法 sqlalchemy.types.NCHAR 中。__init__（length：intNone=无， collation：strNone=无）¶

继承自 sqlalchemy.types.String.__init__ String 的方法

创建字符串保持类型。

参数

length¶ – 可选，用于 DDL 和 CAST 表达式的列的长度。如果没有 CREATE ，则可以安全地省略桌子将发布。某些数据库可能需要 length 在 DDL 中使用，如果 VARCHAR 不包括长度。值是否为解释为 bytes 或 characters 是特定于数据库的。
排序规则¶ –

可选，用于 DDL 和 CAST 表达式的列级排序规则。使用 SQLite、MySQL 和 PostgreSQL 支持的 COLLATE 关键字进行渲染。例如：
```
>>> 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
```
注意

在大多数情况下，Unicode 或 UnicodeText 数据类型应用于预期存储非 ASCII 数据的 Column。这些数据类型将确保在数据库上使用正确的类型。

类 sqlalchemy.types 中。NVARCHAR的¶

SQL NVARCHAR 类型。

成员

__init__（）

类签名

类 sqlalchemy.types.NVARCHAR （sqlalchemy.types.Unicode）

方法 sqlalchemy.types.NVARCHAR 中。__init__（length：intNone=无， collation：strNone=无）¶

继承自 sqlalchemy.types.String.__init__ String 的方法

创建字符串保持类型。

参数

length¶ – 可选，用于 DDL 和 CAST 表达式的列的长度。如果没有 CREATE ，则可以安全地省略桌子将发布。某些数据库可能需要 length 在 DDL 中使用，如果 VARCHAR 不包括长度。值是否为解释为 bytes 或 characters 是特定于数据库的。
排序规则¶ –

可选，用于 DDL 和 CAST 表达式的列级排序规则。使用 SQLite、MySQL 和 PostgreSQL 支持的 COLLATE 关键字进行渲染。例如：
```
>>> 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
```
注意

在大多数情况下，Unicode 或 UnicodeText 数据类型应用于预期存储非 ASCII 数据的 Column。这些数据类型将确保在数据库上使用正确的类型。

类 sqlalchemy.types 中。数值¶

SQL NUMERIC 类型。

另请参阅

Numeric - 基本类型的文档。

成员

__init__（）

类签名

类 sqlalchemy.types.NUMERIC （sqlalchemy.types.Numeric）

方法 sqlalchemy.types.NUMERIC。__init__（precision：intNone=None， scale：intNone=None， decimal_return_scale：intNone=None， asdecimal： bool = True）¶

继承自 sqlalchemy.types.Numeric.__init__ Numeric 的方法

构造一个数值。

参数

precision¶- DDL CREATE 中使用的数值精度 TABLE 的
scale¶ – 在 DDL CREATE TABLE 中使用的数字比例。
asdecimal¶ – 默认为 True。返回值是否应作为 Python Decimal 对象或浮点数发送。不同的 DBAPI 根据数据类型发送一个或另一个 - Numeric 类型将确保 DBAPI 之间的返回值始终如一。
decimal_return_scale¶ – 转换时使用的默认比例从 floats 到 Python decimals。浮点值通常会由于十进制不准确，并且大多数浮点数数据库类型没有 “scale” 的概念，因此默认情况下， float 类型在转换时查找前十位小数。指定此值将覆盖该长度。类型务必包含显式的 “.scale” 值，例如基 numeric 以及 MySQL 浮点类型将使用 “.scale” 的值作为 decimal_return_scale 的默认值（如果未另行指定）。

使用 Numeric 类型时，应注意确保 asdecimal 设置适合正在使用的 DBAPI - 当 Numeric 应用从 Decimal->float 或 float-> Decimal 的转换时，此转换会为收到的所有结果列带来额外的性能开销。

本机返回 Decimal 的 DBAPI（例如 psycopg2）在设置为 True 时将具有更好的准确性和更高的性能，因为本机转换为 Decimal 减少了浮点问题的数量，并且 Numeric 类型本身不需要应用任何进一步的转换。但是，另一个本地返回浮点数的 DBAPI 将产生额外的转换开销，并且仍然会丢失浮点数据 - 在这种情况下，asdecimal=False 至少会消除额外的转换开销。

类 sqlalchemy.types 中。真实¶

SQL REAL 类型。

另请参阅

Float - 基本类型的文档。

成员

__init__（）

类签名

类 sqlalchemy.types.REAL （sqlalchemy.types.Float）

方法 sqlalchemy.types.REAL。__init__（precision：intNone=None， asdecimal： bool = False， decimal_return_scale：intNone=None）¶

继承自 sqlalchemy.types.Float.__init__ Float 的方法

构造一个浮点数。

参数

精度¶ –

在 DDL CREATE 中使用的数值精度TABLE 的后端应尝试确保此精度表示泛型 Float 数据类型。
注意

对于 Oracle Database 后端，渲染 DDL 时不接受 Float.precision 参数，因为 Oracle Database 不支持指定为小数位数的浮点精度。相反，请使用特定于 Oracle Database 的 FLOAT 数据类型并指定 FLOAT.binary_precision 参数。这是 SQLAlchemy 版本 2.0 中的新增功能。

要创建与数据库无关的 Float，请执行单独指定 Oracle Database 的二进制精度，请使用 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 小数时使用的默认比例。由于十进制的不准确，浮点值通常会长得多，并且大多数浮点数据库类型没有“小数位数”的概念，因此默认情况下，浮点类型在转换时查找前十位小数。指定此值将覆盖该长度。请注意，如果未另行指定，则包含 “scale” 的 MySQL 浮点类型将使用 “scale” 作为 decimal_return_scale 的默认值。

类 sqlalchemy.types 中。SMALLINT¶: SQL SMALLINT 类型。

另请参阅

SmallInteger - 基类型的文档。

类签名

类 sqlalchemy.types.SMALLINT （sqlalchemy.types.SmallInteger）

类 sqlalchemy.types 中。文本¶

SQL TEXT 类型。

成员

__init__（）

类签名

类 sqlalchemy.types.TEXT （sqlalchemy.types.Text）

方法 sqlalchemy.types.TEXT 中。__init__（length：intNone=无， collation：strNone=无）¶

继承自 sqlalchemy.types.String.__init__ String 的方法

创建字符串保持类型。

参数

length¶ – 可选，用于 DDL 和 CAST 表达式的列的长度。如果没有 CREATE ，则可以安全地省略桌子将发布。某些数据库可能需要 length 在 DDL 中使用，如果 VARCHAR 不包括长度。值是否为解释为 bytes 或 characters 是特定于数据库的。
排序规则¶ –

可选，用于 DDL 和 CAST 表达式的列级排序规则。使用 SQLite、MySQL 和 PostgreSQL 支持的 COLLATE 关键字进行渲染。例如：
```
>>> 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
```
注意

在大多数情况下，Unicode 或 UnicodeText 数据类型应用于预期存储非 ASCII 数据的 Column。这些数据类型将确保在数据库上使用正确的类型。

类 sqlalchemy.types 中。时间¶: SQL TIME 类型。

类签名

类 sqlalchemy.types.TIME （sqlalchemy.types.Time）

类 sqlalchemy.types 中。时间戳¶

SQL TIMESTAMP 类型。

TIMESTAMP 数据类型支持一些后端，例如 PostgreSQL 和 Oracle Database。使用 TIMESTAMP.timezone 参数，以便为这些后端启用 “TIMESTAMP WITH TIMEZONE”。

成员

__init__（）， get_dbapi_type（）

类签名

类 sqlalchemy.types.TIMESTAMP （sqlalchemy.types.DateTime）

方法 sqlalchemy.types.TIMESTAMP 中。__init__（时区： bool = False）¶

构造新的 TIMESTAMP。

参数: timezone¶ – 布尔值。指示 TIMESTAMP 类型应启用时区支持（如果目标数据库上可用）。按方言（On per dialect）类似于 “TIMESTAMP WITH TIMEZONE”。如果目标数据库不支持时区，则忽略此标志。

方法 sqlalchemy.types.TIMESTAMP 中。get_dbapi_type（dbapi）¶

从底层 DB-API 返回相应的类型对象（如果有）。

例如，这对于调用 setinputsizes（） 很有用。

类 sqlalchemy.types 中。UUID 文件¶

表示 SQL UUID 类型。

这是 UUID 数据库不可知数据类型的 SQL 原生形式，并且向后兼容以前仅限 PostgreSQL 的 UUID 版本。

UUID 数据类型仅适用于具有名为 UUID 的 SQL 数据类型的数据库。它不适用于没有此精确命名类型的后端，包括 SQL Server。对于具有本机支持的后端不可知的 UUID 值，包括 SQL Server 的 UNIQUEIDENTIFIER datatype 中，请使用 Uuid 数据类型。

2.0 版的新Function。

另请参阅

儘

成员

__init__（）

类签名

类 sqlalchemy.types.UUID （sqlalchemy.types.Uuid， sqlalchemy.types.NativeForEmulated ）

方法 sqlalchemy.types.UUID 中。__init__（as_uuid： bool = True）¶

构造 UUID 类型。

参数

as_uuid=真¶ –

如果为 True，则值将被解释为 Python uuid 对象，通过 DBAPI 与字符串相互转换。

类 sqlalchemy.types 中。VARBINARY的¶: SQL VARBINARY 类型。

类签名

类 sqlalchemy.types.VARBINARY （sqlalchemy.types._Binary）

类 sqlalchemy.types 中。VARCHAR 函数¶

SQL VARCHAR 类型。

成员

__init__（）

类签名

类 sqlalchemy.types.VARCHAR （sqlalchemy.types.String）

方法 sqlalchemy.types.VARCHAR 中。__init__（length：intNone=无， collation：strNone=无）¶

继承自 sqlalchemy.types.String.__init__ String 的方法

创建字符串保持类型。

参数

length¶ – 可选，用于 DDL 和 CAST 表达式的列的长度。如果没有 CREATE ，则可以安全地省略桌子将发布。某些数据库可能需要 length 在 DDL 中使用，如果 VARCHAR 不包括长度。值是否为解释为 bytes 或 characters 是特定于数据库的。
排序规则¶ –

可选，用于 DDL 和 CAST 表达式的列级排序规则。使用 SQLite、MySQL 和 PostgreSQL 支持的 COLLATE 关键字进行渲染。例如：
```
>>> 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
```
注意

在大多数情况下，Unicode 或 UnicodeText 数据类型应用于预期存储非 ASCII 数据的 Column。这些数据类型将确保在数据库上使用正确的类型。

SQLAlchemy 2.0 文档

SQLAlchemy 2.0 文档

SQLAlchemy 核心

类型层次结构¶

“CamelCase” 数据类型¶

“UPPERCASE” 数据类型¶

后端特定的 “UPPERCASE” 数据类型¶

为多个后端使用 “UPPERCASE” 和特定于 Backend 的类型¶

泛型 “CamelCase” 类型¶

SQL 标准和多供应商 “UPPERCASE” 类型¶