基本类型 API
| 对象名称 | 描述 |
| Concatenable | 标记类型支持“串联”的混合类型，通常用于字符串。 |
| ExternalType | 定义特定于第三方数据类型的属性和行为的混合类型。 |
| Indexable | 标记类型支持索引操作的混合类型，例如数组或 JSON 结构。 |
| NullType | 未知类型。 |
| TypeEngine | 所有 SQL 数据类型的最终基类。 |
| Variant | 不推荐使用。此符号用于向后兼容性，但实际上不应使用此类型。 |
class sqlalchemy.types.TypeEngine
所有 SQL 数据类型的最终基类。
TypeEngine 的常见子类包括 String、Integer 和 Boolean。
有关 SQLAlchemy 类型系统的概述，请参见 SQL 数据类型对象。
另请参阅
SQL 数据类型对象
成员
operate(), reverse_operate(), adapt(), as_generic(), bind_expression(), bind_processor(), coerce_compared_value(), column_expression(), comparator_factory, compare_values(), compile(), dialect_impl(), evaluates_none(), get_dbapi_type(), hashable, literal_processor(), python_type, render_bind_cast, render_literal_cast, result_processor(), should_evaluate_none, sort_key_function, with_variant()
类签名
类sqlalchemy.types.TypeEngine (sqlalchemy.sql.visitors.Visitable, typing.Generic)
class Comparator
自定义比较操作在类型级别定义的基类。请参见TypeEngine.comparator_factory。
类签名
类sqlalchemy.types.TypeEngine.Comparator (sqlalchemy.sql.expression.ColumnOperators, typing.Generic)
method operate(op: OperatorType, *other: Any, **kwargs: Any) → ColumnElement[_CT]
对参数进行操作。
这是操作的最低级别，默认情况下引发NotImplementedError。
在子类上重写此方法可以使常见行为适用于所有操作。例如，重写ColumnOperators以对左侧和右侧应用func.lower()：
class MyComparator(ColumnOperators): def operate(self, op, other, **kwargs): return op(func.lower(self), func.lower(other), **kwargs)
参数：
op– 运算符可调用。*other– 操作的“其他”一侧。对于大多数操作，它将是一个单一的标量。**kwargs– 修饰符。这些可能由特殊运算符传递，如ColumnOperators.contains()。
method reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → ColumnElement[_CT]
对参数进行反向操作。
使用方法与operate()相同。
method adapt(cls: Type[TypeEngine | TypeEngineMixin], **kw: Any) → TypeEngine
给定一个“impl”类来处理，产生此类型的“适配”形式。
此方法在内部用于将通用类型与特定于特定方言的“实现”类型关联起来。
method as_generic(allow_nulltype: bool = False) → TypeEngine
使用启发式规则返回此类型对应的通用类型的实例。如果此启发式规则不足以满足需求，则可以重写此方法。
>>> from sqlalchemy.dialects.mysql import INTEGER >>> INTEGER(display_width=4).as_generic() Integer()
>>> from sqlalchemy.dialects.mysql import NVARCHAR >>> NVARCHAR(length=100).as_generic() Unicode(length=100)
在 1.4.0b2 版本中新增。
另请参见
使用与数据库无关的类型反射 - 描述了TypeEngine.as_generic()与DDLEvents.column_reflect()事件结合使用的情况，这是其预期的用法。
method bind_expression(bindvalue: BindParameter[_T]) → ColumnElement[_T] | None
给定一个绑定值（即一个BindParameter实例），返回其位置的 SQL 表达式。
这通常是一个 SQL 函数，用于在语句中包装现有的绑定参数。它用于特殊的数据类型，这些类型需要将文本在某些特殊数据库函数中包装，以便将应用程序级值强制转换为数据库特定格式。它是TypeEngine.bind_processor()方法的 SQL 模拟。
此方法在语句的SQL 编译阶段调用，用于呈现 SQL 字符串。它不针对特定值调用。
请注意，当实现此方法时，应始终返回完全相同的结构，不带任何条件逻辑，因为它可能在针对任意数量的绑定参数集的 executemany()调用中使用。
注意
此方法仅针对特定方言类型对象，通常私有于正在使用的方言，并且不是公共类型对象，这意味着无法通过子类化TypeEngine类来提供替代的TypeEngine.bind_expression()方法，除非明确地子类化UserDefinedType类。
要为TypeEngine.bind_expression()提供替代行为，请实现一个TypeDecorator类，并提供一个TypeDecorator.bind_expression()的实现。
另请参见
增强现有类型
另请参见
应用 SQL 级别的绑定/结果处理
method bind_processor(dialect: Dialect) → _BindProcessorType[_T] | None
返回一个转换函数以处理绑定值。
返回一个可调用对象，该对象将接收一个绑定参数值作为唯一的位置参数，并返回一个要发送到 DB-API 的值。
如果不需要处理，则该方法应返回None。
注意
此方法仅针对特定方言类型对象，通常私有于正在使用的方言，并且不是公共类型对象，这意味着无法通过子类化TypeEngine类来提供替代的TypeEngine.bind_processor()方法，除非明确地子类化UserDefinedType类。
要为TypeEngine.bind_processor()提供替代行为，请实现一个TypeDecorator类，并提供一个TypeDecorator.process_bind_param()的实现。
另请参见
增强现有类型
参数：
方言 – 正在使用的方言实例。
method coerce_compared_value(op: OperatorType | None, value: Any) → TypeEngine[Any]
建议为表达式中的‘强制’Python 值提供一种类型。
给定运算符和值，让类型有机会返回一个应该将值强制转换为的类型。
这里的默认行为是保守的；如果右侧已经根据其 Python 类型被强制转换为 SQL 类型，则通常会被保留。
这里的最终用户功能扩展通常应通过TypeDecorator完成，它提供更自由的行为，因为它默认将表达式的另一侧强制转换为此类型，从而应用特殊的 Python 转换，超出了 DBAPI 所需的范围。它还提供了公共方法TypeDecorator.coerce_compared_value()，用于最终用户定制此行为。
method column_expression(colexpr: ColumnElement[_T]) → ColumnElement[_T] | None
给定 SELECT 列表达式，返回包装的 SQL 表达式。
这通常是一个 SQL 函数，它将列表达式包装为在 SELECT 语句的 columns 子句中呈现的形式。它用于特殊数据类型，这些数据类型要求列在发送回应用程序之前必须被包装在某些特殊的数据库函数中以强制转换值。它是 SQL 中TypeEngine.result_processor()方法的类比。
此方法在语句的SQL 编译阶段调用，当呈现 SQL 字符串时。它不会针对特定值调用。
注意
此方法仅相对于特定方言类型对象调用，该对象通常是当前正在使用的方言的私有类型，并且不是公共类型对象，这意味着不可行通过子类化TypeEngine类来提供替代TypeEngine.column_expression()方法，除非显式子类化UserDefinedType类。
要为TypeEngine.column_expression()提供替代行为，请实现一个TypeDecorator类，并提供一个TypeDecorator.column_expression()的实现。
另见
增强现有类型
另见
应用 SQL 级别的绑定/结果处理
attribute comparator_factory
Comparator 的别名
method compare_values(x: Any, y: Any) → bool
比较两个值是否相等。
method compile(dialect: Dialect | None = None) → str
生成此 TypeEngine 的字符串编译形式。
当不带参数调用时，使用“默认”方言来生成字符串结果。
参数：
dialect – 一个 Dialect 实例。
method dialect_impl(dialect: Dialect) → TypeEngine[_T]
返回此 TypeEngine 的特定于方言的实现。
method evaluates_none() → Self
返回具有 should_evaluate_none 标志设置为 True 的此类型的副本。
例如：
Table( 'some_table', metadata, Column( String(50).evaluates_none(), nullable=True, server_default='no value') )
ORM 使用此标志来指示在 INSERT 语句中传递 None 的正值到列中，而不是省略列从 INSERT 语句中，这将触发列级默认值的效果。它还允许具有与 Python None 值关联的特殊行为的类型来指示该值不一定转换为 SQL NULL；一个典型的例子是可能希望持久化 JSON 值 'null' 的 JSON 类型。
在所有情况下，实际的 NULL SQL 值都可以通过在 INSERT 语句中使用 null SQL 构造或与 ORM 映射的属性相关联来始终持久化在任何列中。
注
“evaluates none” 标志 不 适用于传递给 Column.default 或 Column.server_default 的 None 值；在这些情况下，None 仍然表示“无默认值”。
另请参阅
强制具有默认值的列为 NULL - 在 ORM 文档中
JSON.none_as_null - 具有此标志的 PostgreSQL JSON 交互。
TypeEngine.should_evaluate_none - 类级标志
method get_dbapi_type(dbapi: module) → Any | None
返回底层 DB-API 的相应类型对象，如果有的话。
例如，这对于调用 setinputsizes() 可能很有用。
attribute hashable = True
如果 False，则表示来自此类型的值不可哈希。
在 ORM 列表结果去重时使用。
method literal_processor(dialect: Dialect) → _LiteralProcessorType[_T] | None
返回一个转换函数，用于处理直接渲染而不使用绑定的文字值。
当编译器使用“literal_binds”标志时使用此函数，通常用于 DDL 生成以及在某些后端不接受绑定参数的情况下。
返回一个可调用对象，该对象将接收一个字面的 Python 值作为唯一的位置参数，并返回一个字符串表示以在 SQL 语句中呈现。
注意
此方法仅相对于特定方言类型对象调用，该对象通常是正在使用的方言的私有对象，并不是公共类型对象，这意味着不太可能为了提供替代的TypeEngine.literal_processor()方法而对TypeEngine类进行子类化，除非显式地对UserDefinedType类进行子类化。
要为TypeEngine.literal_processor()提供替代行为，请实现一个TypeDecorator类，并提供一个TypeDecorator.process_literal_param()的实现。
另请参阅
增强现有类型
attribute python_type
返回此类型实例预计返回的 Python 类型对象，如果已知的话。
基本上，对于那些强制指定返回类型的类型，或者已知在所有常见的 DBAPI 中都会对所有类型进行这样的操作的类型（例如int），将返回该类型。
如果未定义返回类型，则引发NotImplementedError。
注意，在 SQL 中，任何类型也可以容纳 NULL，这意味着你在实践中也可以从任何类型中获得None。
attribute render_bind_cast = False
渲染绑定转换以适应BindTyping.RENDER_CASTS模式。
如果为 True，则此类型（通常是一个方言级别的实现类型）向编译器发出信号，表示应该在此类型的绑定参数周围呈现一个转换。
2.0 版本中的新功能。
另请参阅
BindTyping
attribute render_literal_cast = False
渲染转换当渲染一个值作为内联字面值时，例如通过TypeEngine.literal_processor()。
2.0 版本中的新功能。
method result_processor(dialect: Dialect, coltype: object) → _ResultProcessorType[_T] | None
返回一个用于处理结果行值的转换函数。
返回一个可调用对象，该对象将接收一个结果行列值作为唯一的位置参数，并返回一个要返回给用户的值。
如果不需要处理，则方法应返回None。
注意
此方法仅相对于特定方言类型对象调用，该对象通常是正在使用的方言私有的，并且不是与公共类型对象相同的类型对象，这意味着无法通过子类化TypeEngine类来提供替代的TypeEngine.result_processor()方法，除非明确子类化UserDefinedType类。
要为TypeEngine.result_processor()提供替代行为，请实现一个TypeDecorator类，并提供一个TypeDecorator.process_result_value()的实现。
另请参见
增强现有类型
参数：
dialect– 正在使用的方言实例。coltype– 在cursor.description中接收到的 DBAPI coltype 参数。
attribute should_evaluate_none: bool = False
如果为 True，则 Python 常量None被认为是此类型明确处理的。
ORM 使用此标志表示在 INSERT 语句中将正值的None传递给列，而不是从 INSERT 语句中省略列，这会触发列级默认值。它还允许具有 Python None 的特殊行为的类型（例如 JSON 类型）明确指示它们希望显式处理 None 值。
要在现有类型上设置此标志，请使用TypeEngine.evaluates_none()方法。
另请参见
TypeEngine.evaluates_none()
attribute sort_key_function: Callable[[Any], Any] | None = None
作为传递给 sorted 的键的排序函数。
默认值为None表示此类型存储的值是自动排序的。
1.3.8 版中的新功能。
method with_variant(type_: _TypeEngineArgument[Any], *dialect_names: str) → Self
生成此类型对象的副本，该副本将在应用于给定名称的方言时使用给定的类型。
例如：
from sqlalchemy.types import String from sqlalchemy.dialects import mysql string_type = String() string_type = string_type.with_variant( mysql.VARCHAR(collation='foo'), 'mysql', 'mariadb' )
变体映射表示当特定方言解释此类型时，它将被转换为给定类型，而不是使用主类型。
从版本 2.0 开始更改：TypeEngine.with_variant()方法现在在“就地”操作TypeEngine对象时工作，返回原始类型的副本，而不是返回包装对象；不再使用Variant类。
参数：
type_– 一个TypeEngine，当使用给定名称的方言时，将从原始类型中选择作为变体。*dialect_names–
使用此类型的方言的一个或多个基本名称（即'postgresql'，'mysql'等）
从 2.0 版本开始更改：可以为一个变体指定多个方言名称。
另请参见
使用“大写字母”和后端特定类型的多后端 - 演示了TypeEngine.with_variant()的使用。
class sqlalchemy.types.Concatenable
一个将类型标记为支持“连接”的 mixin，通常是字符串。
成员
comparator_factory
类签名
类sqlalchemy.types.Concatenable（sqlalchemy.types.TypeEngineMixin）
class Comparator
类签名
类sqlalchemy.types.Concatenable.Comparator（sqlalchemy.types.Comparator）
attribute comparator_factory
Comparator的别名
class sqlalchemy.types.Indexable
一个将类型标记为支持索引操作的 mixin，例如数组或 JSON 结构。
成员
comparator_factory
类签名
类sqlalchemy.types.Indexable（sqlalchemy.types.TypeEngineMixin）
class Comparator
类签名
类sqlalchemy.types.Indexable.Comparator（sqlalchemy.types.Comparator）
attribute comparator_factory
Comparator的别名
class sqlalchemy.types.NullType
一个未知类型。
NullType用作那些无法确定类型的情况的默认类型，包括：
- 在表反射期间，当列的类型未被
Dialect识别时 - 当使用未知类型的纯 Python 对象构建 SQL 表达式时（例如
somecolumn == my_special_object） - 当创建新的
Column时，并且给定类型传递为None或根本不传递时。
NullType 可以在 SQL 表达式调用中使用，没有问题，只是在表达式构造级别或绑定参数/结果处理级别上没有行为。
类签名
class sqlalchemy.types.NullType (sqlalchemy.types.TypeEngine)
class sqlalchemy.types.ExternalType
定义特定于第三方数据类型的属性和行为的混合项。
“第三方”指的是在 SQLAlchemy 范围之外定义的数据类型，在最终用户应用代码中或在 SQLAlchemy 的外部扩展中定义。
当前的子类包括 TypeDecorator 和 UserDefinedType。
版本 1.4.28 中的新功能。
成员
cache_ok
类签名
class sqlalchemy.types.ExternalType (sqlalchemy.types.TypeEngineMixin)
attribute cache_ok: bool | None = None
表示使用此 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')
如果我们设置了这样一个缓存键，它将无法使用。我们将得到一个包含字典的元组结构，该字典本身不能作为“缓存字典”中的键使用，因为 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 编译缓存
class sqlalchemy.types.Variant
已弃用。符号用于向后兼容解决方案配方，但不应使用此实际类型。
成员
with_variant()
类签名
类sqlalchemy.types.Variant（sqlalchemy.types.TypeDecorator）
method with_variant(type_: _TypeEngineArgument[Any], *dialect_names: str) → Self
继承自 TypeEngine.with_variant() 方法的 TypeEngine
生成将在应用于给定名称的方言时利用给定类型的此类型对象的副本。
例如：
from sqlalchemy.types import String from sqlalchemy.dialects import mysql string_type = String() string_type = string_type.with_variant( mysql.VARCHAR(collation='foo'), 'mysql', 'mariadb' )
变体映射表示，当特定方言解释此类型时，它将被转换为给定类型，而不是使用主要类型。
版本 2.0 中更改：TypeEngine.with_variant()方法现在与TypeEngine对象“原地”工作，返回原始类型的副本，而不是返回包装对象；不再使用Variant类。
参数：
type_– 一个TypeEngine，当使用给定名称的方言时，将从原始类型中选择作为变体的类型。*dialect_names*–
使用此类型的方言的一个或多个基本名称。（即'postgresql'，'mysql'等）
版本 2.0 中的变更：一个变体可以指定多个方言名称。
另请参阅
使用“大写”和后端特定类型进行多后端处理 - 演示了 TypeEngine.with_variant() 的使用。
引擎和连接使用
- 引擎配置
- 支持的数据库
- 数据库 URL
- 转义特殊字符，如密码中的@符号
- 程序化创建 URL
- 特定后端的 URL
- 引擎创建 API
create_engine()engine_from_config()create_mock_engine()make_url()create_pool_from_url()URL
- 连接池
- 自定义 DBAPI connect()参数 / 连接时例程
- 传递给 dbapi.connect()的特殊关键字参数
- 控制参数如何传递给 DBAPI connect()函数
- 连接后修改 DBAPI 连接，或连接后运行命令
- 完全替换 DBAPI
connect()函数
- 配置日志记录
- 更多关于 Echo 标志的信息
- 设置日志名称
- 设置每个连接/子引擎令牌
- 隐藏参数
- 使用引擎和连接
- 基本用法
- 使用事务
- 边用边提交
- 一次性开始
- 从引擎连接和一次性开始
- 混合风格
- 设置事务隔离级别，包括 DBAPI 自动提交
- 为连接设置隔离级别或 DBAPI 自动提交
- 为引擎设置隔离级别或 DBAPI 自动提交
- 为单个引擎维护多个隔离级别
- 理解 DBAPI 级别的自动提交隔离级别
- 使用服务器端游标（即流式结果）
- 通过 yield_per 进行固定缓冲区流式处理
- 通过 stream_results 使用动态增长缓冲区进行流式处理
- 模式名称的翻译
- SQL 编译缓存
- 配置
- 使用日志估算缓存性能
- 缓存使用多少内存？
- 禁用或使用备用字典缓存部分（或全部）语句
- 为第三方方言进行缓存
- 使用 Lambda 函数为语句生成提速
- “插入多个值”行为适用于 INSERT 语句
- 当前支持
- 禁用该特性
- 批处理模式操作
- 将 RETURNING 行与参数集相关联
- 非批处理模式操作
- 语句执行模型
- 控制批处理大小
- 日志和事件
- Upsert 支持
- 引擎释放
- 与 Driver SQL 和原始 DBAPI 连接一起工作
- 直接调用驱动程序的 SQL 字符串
- 直接使用 DBAPI 游标
- 调用存储过程和用户定义函数
- 多结果集
- 注册新方言
- 进程内注册方言
- 连接 / 引擎 API
ConnectionCreateEnginePluginEngineExceptionContextNestedTransactionRootTransactionTransactionTwoPhaseTransaction
- 结果集 API
ChunkedIteratorResultCursorResultFilterResultFrozenResultIteratorResultMergedResultResultScalarResultMappingResultRowRowMappingTupleResult
- 连接池
- 连接池配置
- 切换池实现
- 使用自定义连接函数
- 构建池
- 返回时重置
- 对于非事务连接禁用返回时重置
- 自定义返回时重置方案
- 记录返回时重置事件
- 池事件
- 处理断开连接
- 断开处理 - 悲观
- 断开处理 - 乐观
- 更多关于失效的信息
- 支持断开情景下的新数据库错误代码
- 使用 FIFO vs. LIFO
- 在多进程或 os.fork() 中使用连接池
- 直接使用池实例
- API 文档 - 可用的池实现
PoolQueuePoolAsyncAdaptedQueuePoolSingletonThreadPoolAssertionPoolNullPoolStaticPoolManagesConnectionConnectionPoolEntryPoolProxiedConnection_ConnectionFairy_ConnectionRecord
- 核心事件
事件
Events.dispatch
- 连接池事件
PoolEventsPoolResetState
- SQL 执行和连接事件
ConnectionEventsDialectEvents
- 模式事件
DDLEventsSchemaEventTarget
引擎配置
Engine 是任何 SQLAlchemy 应用的起点。它是实际数据库和通过连接池和 Dialect 传递给 SQLAlchemy 应用程序的 DBAPI 的“主基地”，Dialect 描述了如何与特定类型的数据库/DBAPI 组合进行通信。
通用结构可如下所示：
在上述中，Engine 同时引用了 Dialect 和 Pool，它们一起解释了 DBAPI 的模块函数以及数据库的行为。
创建引擎只需发出一个单独的调用，create_engine()：
from sqlalchemy import create_engine engine = create_engine("postgresql+psycopg2://scott:tiger@localhost:5432/mydatabase")
上述引擎创建了一个针对 PostgreSQL 定制的 Dialect 对象，以及一个 Pool 对象，当首次收到连接请求时，将在 localhost:5432 建立 DBAPI 连接。请注意，Engine 及其底层的 Pool 在首次调用 Engine.connect() 或 Engine.begin() 方法之前都不会建立第一个实际的 DBAPI 连接。当其他 SQLAlchemy Engine 依赖对象（例如首次需要数据库连接时的 ORM Session 对象）首次需要数据库连接时，也可以调用这些方法中的任何一个。通过这种方式，Engine 和 Pool 可以说具有延迟初始化行为。
一旦创建了 Engine，它可以直接用于与数据库交互，也可以传递给一个 Session 对象以与 ORM 一起使用。本节介绍了配置 Engine 的详细信息。下一节，使用 Engines 和 Connections，将详细介绍 Engine 和类似对象的使用 API，通常用于非 ORM 应用程序。
SqlAlchemy 2.0 中文文档（四十三）（2）https://developer.aliyun.com/article/1563060
