核心内部结构¶

这里列出了一些关键的内部结构。

对象名称	描述
AdaptedConnection	一个适配连接对象的接口，用于支持 DBAPI 协议。
BindTyping	定义在将语句中绑定参数的类型信息传递给数据库驱动程序时使用不同方法。
Compiled	表示已编译的 SQL 或 DDL 表达式。
DBAPIConnection	表示 PEP 249 数据库连接的协议。
DBAPICursor	表示 PEP 249 数据库游标的协议。
DBAPIType	表示 PEP 249 数据库类型的协议。
DDLCompiler
DefaultDialect	Dialect 的默认实现。
DefaultExecutionContext
Dialect	定义特定数据库和 DB-API 组合的行为。
ExecutionContext	与单个执行相对应的 Dialect 的消息传递对象。
ExpandedState	表示在生成语句的“扩展”和“编译后”绑定参数时使用的状态。
GenericTypeCompiler
Identified
IdentifierPreparer	根据选项处理标识符的引用和大小写折叠。
SQLCompiler	`Compiled` 的默认实现。
StrSQLCompiler	一个 `SQLCompiler` 子类，它允许将少量非标准 SQL 特性呈现为字符串值。

class sqlalchemy.engine.BindTyping¶

定义在将语句中绑定参数的类型信息传递给数据库驱动程序时使用不同方法。

版本 2.0 中新增。

成员

NONE, RENDER_CASTS, SETINPUTSIZES

类签名

class sqlalchemy.engine.BindTyping (enum.Enum)

attribute sqlalchemy.engine.BindTyping.NONE = 1¶

不采取任何步骤将类型信息传递给数据库驱动程序。

这是 SQLite、MySQL / MariaDB、SQL Server 等数据库的默认行为。

attribute sqlalchemy.engine.BindTyping.RENDER_CASTS = 3¶

在 SQL 字符串中呈现强制转换或其他指令。

此方法用于所有 PostgreSQL 方言，包括 asyncpg、pg8000、psycopg、psycopg2。实现此方法的方言可以选择在 SQL 语句中显式强制转换哪些类型，哪些不强制转换。

使用 RENDER_CASTS 时，编译器将为每个 BindParameter 对象调用 SQLCompiler.render_bind_cast() 方法，该对象的方言级类型设置了 TypeEngine.render_bind_cast 属性。

SQLCompiler.render_bind_cast() 也用于为一种“insertmanyvalues”查询呈现强制转换，当 InsertmanyvaluesSentinelOpts.USE_INSERT_FROM_SELECT 和 InsertmanyvaluesSentinelOpts.RENDER_SELECT_COL_CASTS 都设置时，强制转换将应用于中间列，例如“INSERT INTO t (a, b, c) SELECT p0::TYP, p1::TYP, p2::TYP ” “FROM (VALUES (?, ?), (?, ?), …)”。

版本 2.0.10 中新增: - SQLCompiler.render_bind_cast() 现在在“insertmanyvalues”实现的某些元素中使用。

attribute sqlalchemy.engine.BindTyping.SETINPUTSIZES = 2¶

使用 pep-249 setinputsizes 方法。

这仅针对支持此方法的 DBAPI 以及 SQLAlchemy 方言为此方言设置了适当的基础结构的 DBAPI 实现。当前方言包括 cx_Oracle 以及使用 pyodbc 对 SQL Server 的可选支持。

使用 setinputsizes 时，方言还有一种方法，可以只对某些数据类型使用该方法，使用 include/exclude 列表。

使用 SETINPUTSIZES 时，将为每个执行的语句调用 Dialect.do_set_input_sizes() 方法，该语句具有绑定参数。

class sqlalchemy.engine.Compiled¶

表示已编译的 SQL 或 DDL 表达式。

成员

__init__(), cache_key, compile_state, construct_params(), dml_compile_state, execution_options, params, sql_compiler, state, statement, string

Compiled 对象的 __str__ 方法应该生成语句的实际文本。 Compiled 对象特定于其底层数据库方言，并且可能也可能不特定于特定绑定参数集中引用的列。在任何情况下，Compiled 对象都不应该依赖于这些绑定参数的实际值，即使它可能将这些值作为默认值引用。

method sqlalchemy.engine.Compiled.__init__(dialect: Dialect, statement: ClauseElement | None, schema_translate_map: SchemaTranslateMapType | None = None, render_schema_translate: bool = False, compile_kwargs: Mapping[str, Any] = {})¶

构造一个新的 Compiled 对象。

参数:

dialect¶ – 用于编译的 Dialect。
statement¶ – 要编译的 ClauseElement。
schema_translate_map¶ –
在形成最终 SQL 时要转换的模式名称字典。

另请参见

模式名称的转换
compile_kwargs¶ – 将传递给 Compiled.process() 的初始调用的其他 kwargs。

attribute sqlalchemy.engine.Compiled.cache_key: CacheKey | None = None¶

创建此 Compiled 对象之前生成的 CacheKey。

这用于需要访问在最初缓存 Compiled 实例时生成的原始 CacheKey 实例的例程，通常是为了将原始的 BindParameter 对象列表与每次调用时生成的每个语句列表进行协调。

attribute sqlalchemy.engine.Compiled.compile_state: CompileState | None = None¶

可选的 CompileState 对象，它维护编译器使用的额外状态。

主要的执行对象，如 Insert、Update、Delete、Select 将在编译时生成此状态，以便计算有关对象的其他信息。对于要执行的顶级对象，状态可以存储在此处，它也可以对结果集处理具有适用性。

版本 1.4 中的新功能。

method sqlalchemy.engine.Compiled.construct_params(params: _CoreSingleExecuteParams | None = None, extracted_parameters: Sequence[BindParameter[Any]] | None = None, escape_names: bool = True) → _MutableCoreSingleExecuteParams | None¶

返回此已编译对象的绑定参数。

参数:: params¶ – 字符串/对象对的字典，其值将覆盖编译到语句中的绑定值。

attribute sqlalchemy.engine.Compiled.dml_compile_state: CompileState | None = None¶

在分配 .isinsert、.isupdate 或 .isdelete 的同时分配的可选 CompileState。

这通常与 .compile_state 相同，除了像 ORMFromStatementCompileState 对象这样的情况。

版本 1.4.40 中的新功能。

attribute sqlalchemy.engine.Compiled.execution_options: _ExecuteOptions = {}¶: 从语句中传播的执行选项。在某些情况下，语句的子元素可以修改这些选项。

attribute sqlalchemy.engine.Compiled.params¶: 返回此已编译对象的绑定参数。

属性 sqlalchemy.engine.Compiled.sql_compiler¶

返回一个能够处理 SQL 表达式的 Compiled 对象。

如果此编译器本身就是一个，它很可能只是返回“self”。

属性 sqlalchemy.engine.Compiled.state: CompilerState¶: 编译器状态的描述。

属性 sqlalchemy.engine.Compiled.statement: ClauseElement | None = None¶: 要编译的语句。

属性 sqlalchemy.engine.Compiled.string: str = ''¶: statement 的字符串表示形式。

类 sqlalchemy.engine.interfaces.DBAPIConnection¶

表示 PEP 249 数据库连接的协议。

版本 2.0 中新增。

另请参见

连接对象 - 在 PEP 249 中。

成员

autocommit, close(), commit(), cursor(), rollback()

类签名

class sqlalchemy.engine.interfaces.DBAPIConnection (typing_extensions.Protocol)

属性 sqlalchemy.engine.interfaces.DBAPIConnection.autocommit: bool¶

方法 sqlalchemy.engine.interfaces.DBAPIConnection.close() → None¶

方法 sqlalchemy.engine.interfaces.DBAPIConnection.commit() → None¶

方法 sqlalchemy.engine.interfaces.DBAPIConnection.cursor() → DBAPICursor¶

方法 sqlalchemy.engine.interfaces.DBAPIConnection.rollback() → None¶

类 sqlalchemy.engine.interfaces.DBAPICursor¶

表示 PEP 249 数据库游标的协议。

版本 2.0 中新增。

另请参见

游标对象 - 在 PEP 249 中。

成员

arraysize, callproc(), close(), description, execute(), executemany(), fetchall(), fetchmany(), fetchone(), lastrowid, nextset(), rowcount, setinputsizes(), setoutputsize()

类签名

class sqlalchemy.engine.interfaces.DBAPICursor (typing_extensions.Protocol)

属性 sqlalchemy.engine.interfaces.DBAPICursor.arraysize: int¶

方法 sqlalchemy.engine.interfaces.DBAPICursor.callproc(procname: str, parameters: Sequence[Any] = Ellipsis) → Any¶

方法 sqlalchemy.engine.interfaces.DBAPICursor.close() → None¶

属性 sqlalchemy.engine.interfaces.DBAPICursor.description¶: 游标的 description 属性。

另请参见

cursor.description - 在 PEP 249 中。

方法 sqlalchemy.engine.interfaces.DBAPICursor.execute(operation: Any, parameters: Sequence[Any] | Mapping[str, Any] | None = None) → Any¶

方法 sqlalchemy.engine.interfaces.DBAPICursor.executemany(operation: Any, parameters: Sequence[Sequence[Any]] | Sequence[Mapping[str, Any]]) → Any¶

方法 sqlalchemy.engine.interfaces.DBAPICursor.fetchall() → Sequence[Any]¶

方法 sqlalchemy.engine.interfaces.DBAPICursor.fetchmany(size: int = Ellipsis) → Sequence[Any]¶

方法 sqlalchemy.engine.interfaces.DBAPICursor.fetchone() → Any | None¶

属性 sqlalchemy.engine.interfaces.DBAPICursor.lastrowid: int¶

方法 sqlalchemy.engine.interfaces.DBAPICursor.nextset() → bool | None¶

属性 sqlalchemy.engine.interfaces.DBAPICursor.rowcount¶

方法 sqlalchemy.engine.interfaces.DBAPICursor.setinputsizes(sizes: Sequence[Any]) → None¶

方法 sqlalchemy.engine.interfaces.DBAPICursor.setoutputsize(size: Any, column: Any) → None¶

类 sqlalchemy.engine.interfaces.DBAPIType¶: 表示 PEP 249 数据库类型的协议。

版本 2.0 中新增。

另请参见

类型对象 - 在 PEP 249

类签名

类 sqlalchemy.engine.interfaces.DBAPIType (typing_extensions.Protocol)

类 sqlalchemy.sql.compiler.DDLCompiler¶

成员

__init__(), cache_key, compile_state, construct_params(), define_constraint_remote_table(), dml_compile_state, execution_options, params, sql_compiler, state, statement, string

类签名

类 sqlalchemy.sql.compiler.DDLCompiler (sqlalchemy.sql.compiler.Compiled)

方法 sqlalchemy.sql.compiler.DDLCompiler.__init__(dialect: Dialect, statement: ClauseElement | None, schema_translate_map: SchemaTranslateMapType | None = None, render_schema_translate: bool = False, compile_kwargs: Mapping[str, Any] = {})¶

继承自 sqlalchemy.sql.compiler.Compiled.__init__ 方法 Compiled

构造一个新的 Compiled 对象。

参数:

dialect¶ – Dialect 用于编译。
statement¶ – ClauseElement 将被编译。
schema_translate_map¶ –
在形成最终 SQL 时要转换的模式名称字典。

另请参见

模式名称的转换
compile_kwargs¶ – 将传递给 Compiled.process() 的初始调用的额外关键字参数。

属性 sqlalchemy.sql.compiler.DDLCompiler.cache_key: CacheKey | None = None¶

继承自 Compiled.cache_key 属性的 Compiled

在创建此 Compiled 对象之前生成的 CacheKey。

这用于需要访问原始 CacheKey 实例的例程，该实例是在 Compiled 实例首次缓存时生成的，通常是为了协调原始的 BindParameter 对象列表与每次调用时生成的每个语句列表。

attribute sqlalchemy.sql.compiler.DDLCompiler.compile_state: CompileState | None = None¶

继承自 Compiled.compile_state 属性的 Compiled

可选的 CompileState 对象，它维护编译器使用的额外状态。

主要的执行对象，如 Insert、Update、Delete、Select 将在编译时生成此状态，以便计算有关对象的其他信息。对于要执行的顶级对象，状态可以存储在此处，它也可以对结果集处理具有适用性。

版本 1.4 中的新功能。

method sqlalchemy.sql.compiler.DDLCompiler.construct_params(params: _CoreSingleExecuteParams | None = None, extracted_parameters: Sequence[BindParameter[Any]] | None = None, escape_names: bool = True) → _MutableCoreSingleExecuteParams | None¶

返回此已编译对象的绑定参数。

参数:: params¶ – 一个字符串/对象对的字典，其值将覆盖编译到语句中的绑定值。

method sqlalchemy.sql.compiler.DDLCompiler.define_constraint_remote_table(constraint, table, preparer)¶: 格式化 CREATE CONSTRAINT 子句的远程表子句。

attribute sqlalchemy.sql.compiler.DDLCompiler.dml_compile_state: CompileState | None = None¶

继承自 Compiled.dml_compile_state 属性的 Compiled

在分配 .isinsert、.isupdate 或 .isdelete 的同时分配的可选 CompileState。

这通常与 .compile_state 相同，除了像 ORMFromStatementCompileState 对象这样的情况。

版本 1.4.40 中的新功能。

attribute sqlalchemy.sql.compiler.DDLCompiler.execution_options: _ExecuteOptions = {}¶: 继承自 Compiled.execution_options 属性的 Compiled

从语句中传播的执行选项。在某些情况下，语句的子元素可以修改这些选项。

attribute sqlalchemy.sql.compiler.DDLCompiler.params¶: 继承自 Compiled.params 属性的 Compiled

返回此已编译对象的绑定参数。

attribute sqlalchemy.sql.compiler.DDLCompiler.sql_compiler¶

attribute sqlalchemy.sql.compiler.DDLCompiler.state: CompilerState¶: 编译器状态的描述。

attribute sqlalchemy.sql.compiler.DDLCompiler.statement: ClauseElement | None = None¶: 继承自 Compiled.statement 属性的 Compiled

要编译的语句。

attribute sqlalchemy.sql.compiler.DDLCompiler.string: str = ''¶: 继承自 Compiled.string 属性的 Compiled

statement 的字符串表示形式。

class sqlalchemy.engine.default.DefaultDialect¶

Dialect 的默认实现。

成员

bind_typing, colspecs, connect(), construct_arguments, create_connect_args(), create_xid(), cte_follows_insert, dbapi, dbapi_exception_translation_map, ddl_compiler, default_isolation_level, default_metavalue_token, default_schema_name, default_sequence_base, delete_executemany_returning, delete_returning, delete_returning_multifrom, denormalize_name(), div_is_floordiv, do_begin(), do_begin_twophase(), do_close(), do_commit(), do_commit_twophase(), do_execute(), do_execute_no_params(), do_executemany(), do_ping(), do_prepare_twophase(), do_recover_twophase(), do_release_savepoint(), do_rollback(), do_rollback_to_savepoint(), do_rollback_twophase(), do_savepoint(), do_set_input_sizes(), do_terminate(), driver, engine_config_types, engine_created(), exclude_set_input_sizes, execute_sequence_format, execution_ctx_cls, favor_returning_over_lastrowid, full_returning, get_async_dialect_cls(), get_check_constraints(), get_columns(), get_default_isolation_level(), get_dialect_cls(), get_dialect_pool_class(), get_driver_connection(), get_foreign_keys(), get_indexes(), get_isolation_level(), get_isolation_level_values(), get_materialized_view_names(), get_multi_check_constraints(), get_multi_columns(), get_multi_foreign_keys(), get_multi_indexes(), get_multi_pk_constraint(), get_multi_table_comment(), get_multi_table_options(), get_multi_unique_constraints(), get_pk_constraint(), get_schema_names(), get_sequence_names(), get_table_comment(), get_table_names(), get_table_options(), get_temp_table_names(), get_temp_view_names(), get_unique_constraints(), get_view_definition(), get_view_names(), has_index(), has_schema(), has_sequence(), has_table(), has_terminate, identifier_preparer, import_dbapi(), include_set_input_sizes, initialize(), inline_comments, insert_executemany_returning, insert_executemany_returning_sort_by_parameter_order, insert_returning, insertmanyvalues_implicit_sentinel, insertmanyvalues_max_parameters, insertmanyvalues_page_size, is_async, is_disconnect(), label_length, load_provisioning(), loaded_dbapi, max_identifier_length, name, normalize_name(), on_connect(), on_connect_url(), paramstyle, positional, preexecute_autoincrement_sequences, preparer, reflection_options, reset_isolation_level(), returns_native_bytes, sequences_optional, server_side_cursors, server_version_info, set_connection_execution_options(), set_engine_execution_options(), set_isolation_level(), statement_compiler, supports_alter, supports_comments, supports_constraint_comments, supports_default_metavalue, supports_default_values, supports_empty_insert, supports_identity_columns, supports_multivalues_insert, supports_native_boolean, supports_native_decimal, supports_native_enum, supports_native_uuid, supports_sane_multi_rowcount, supports_sane_rowcount, supports_sane_rowcount_returning, supports_sequences, supports_server_side_cursors, supports_simple_order_by_label, supports_statement_cache, tuple_in_values, type_compiler, type_compiler_cls, type_compiler_instance, type_descriptor(), update_executemany_returning, update_returning, update_returning_multifrom, use_insertmanyvalues, use_insertmanyvalues_wo_returning

类签名

class sqlalchemy.engine.default.DefaultDialect (sqlalchemy.engine.interfaces.Dialect)

attribute sqlalchemy.engine.default.DefaultDialect.bind_typing = 1¶

定义将类型信息传递给数据库和/或驱动程序以进行绑定参数的方法。

请参阅 BindTyping 以了解值。

版本 2.0 中新增。

attribute sqlalchemy.engine.default.DefaultDialect.colspecs: MutableMapping[Type[TypeEngine[Any]], Type[TypeEngine[Any]]] = {}¶: 来自 sqlalchemy.types 的 TypeEngine 类映射到特定于方言类的子类的字典。此字典仅在类级别，不会从方言实例本身访问。

method sqlalchemy.engine.default.DefaultDialect.connect(*cargs, **cparams)¶

使用此方言的 DBAPI 建立连接。

此方法的默认实现是

def connect(self, *cargs, **cparams):
    return self.dbapi.connect(*cargs, **cparams)

参数 *cargs, **cparams 直接从该方言的 Dialect.create_connect_args() 方法生成。

该方法可用于当从 DBAPI 获取新连接时需要执行按连接编程步骤的方言。

参数:

*cargs¶ – 从 Dialect.create_connect_args() 方法返回的位置参数
**cparams¶ – 从 Dialect.create_connect_args() 方法返回的关键字参数。

返回值:

DBAPI 连接，通常来自 PEP 249 模块级 .connect() 函数。

另请参见

Dialect.create_connect_args()

Dialect.on_connect()

attribute sqlalchemy.engine.default.DefaultDialect.construct_arguments: List[Tuple[Type[SchemaItem | ClauseElement], Mapping[str, Any]]] | None = None¶

从 Dialect.construct_arguments 属性继承 Dialect

各种 SQLAlchemy 结构（通常是模式项）的可选参数规范集。

要实现，请建立一系列元组，如下所示

construct_arguments = [
    (schema.Index, {
        "using": False,
        "where": None,
        "ops": None
    })
]

如果上述结构在 PostgreSQL 方言上建立，则 Index 结构现在将接受关键字参数 postgresql_using、postgresql_where 和 postgresql_ops。任何其他指定给 Index 构造函数的参数，如果以 postgresql_ 为前缀，则会引发 ArgumentError。

没有包含 construct_arguments 成员的方言将不会参与参数验证系统。对于这样的方言，所有参与的结构都接受任何参数名称，在以该方言名称为前缀的参数命名空间内。这里的理由是，尚未实现此功能的第三方方言继续以旧的方式运行。

另请参见

DialectKWArgs - 实现消耗 DefaultDialect.construct_arguments 的基类

method sqlalchemy.engine.default.DefaultDialect.create_connect_args(url)¶

构建与 DBAPI 兼容的连接参数。

给定一个 URL 对象，返回一个包含 (*args, **kwargs) 的元组，适合直接发送到 dbapi 的 connect 函数。这些参数被发送到 Dialect.connect() 方法，该方法然后运行 DBAPI 级别的 connect() 函数。

该方法通常利用 URL.translate_connect_args() 方法来生成选项字典。

默认实现为

def create_connect_args(self, url):
    opts = url.translate_connect_args()
    opts.update(url.query)
    return ([], opts)

参数:: url¶ – URL 对象
返回值:: 将传递给 Dialect.connect() 方法的 (*args, **kwargs) 元组。

另请参见

URL.translate_connect_args()

method sqlalchemy.engine.default.DefaultDialect.create_xid()¶

创建随机的两阶段事务 ID。

此 ID 将传递给 do_begin_twophase()、do_rollback_twophase()、do_commit_twophase()。它的格式未指定。

attribute sqlalchemy.engine.default.DefaultDialect.cte_follows_insert: bool = False¶: 目标数据库，当给定一个带有 INSERT 语句的 CTE 时，需要将 CTE 放在 INSERT 之后

attribute sqlalchemy.engine.default.DefaultDialect.dbapi: ModuleType | None¶

对 DBAPI 模块对象本身的引用。

SQLAlchemy 方言使用类方法 Dialect.import_dbapi() 导入 DBAPI 模块。这样做的理由是，任何方言模块都可以导入并用于生成 SQL 语句，而无需实际安装 DBAPI 驱动程序。只有当使用 Engine 构造 create_engine() 时，才会导入 DBAPI；此时，创建过程将 DBAPI 模块分配给此属性。

因此，方言应该实现 Dialect.import_dbapi()，它将导入必要的模块并返回它，然后在方言代码中引用 self.dbapi 来引用 DBAPI 模块的内容。

在版本 The 中更改: Dialect.dbapi 属性专门用作对 DBAPI 模块的每个 Dialect 实例的引用。以前未完全记录的 .Dialect.dbapi() 类方法已弃用，并由 Dialect.import_dbapi() 替换。

attribute sqlalchemy.engine.default.DefaultDialect.dbapi_exception_translation_map: Mapping[str, str] = {}¶: 从 Dialect.dbapi_exception_translation_map 属性继承 Dialect

一个名称字典，该字典将包含 pep-249 异常（“IntegrityError”、“OperationalError”等）的名称作为值，并以备用类名作为键，以支持 DBAPI 具有未按引用方式命名的异常类的情况（例如 IntegrityError = MyException）。在绝大多数情况下，此字典为空。

attribute sqlalchemy.engine.default.DefaultDialect.ddl_compiler¶: 的别名 DDLCompiler

attribute sqlalchemy.engine.default.DefaultDialect.default_isolation_level: IsolationLevel | None¶: 新连接隐式存在的隔离级别。

attribute sqlalchemy.engine.default.DefaultDialect.default_metavalue_token: str = 'DEFAULT'¶: 对于 INSERT… VALUES (DEFAULT) 语法，括号中要放置的标记。

attribute sqlalchemy.engine.default.DefaultDialect.default_schema_name: str | None = None¶: 默认模式的名称。此值仅适用于支持的方言，通常在首次连接到数据库时填充。

attribute sqlalchemy.engine.default.DefaultDialect.default_sequence_base: int = 1¶: 将作为 CREATE SEQUENCE DDL 语句的“START WITH”部分呈现的默认值。

attribute sqlalchemy.engine.default.DefaultDialect.delete_executemany_returning: bool = False¶: 方言支持使用 executemany 的 DELETE..RETURNING。

attribute sqlalchemy.engine.default.DefaultDialect.delete_returning: bool = False¶: 如果方言支持使用 DELETE 的 RETURNING。

版本 2.0 中新增。

attribute sqlalchemy.engine.default.DefaultDialect.delete_returning_multifrom: bool = False¶: 如果方言支持使用 DELETE..FROM 的 RETURNING。

版本 2.0 中新增。

method sqlalchemy.engine.default.DefaultDialect.denormalize_name(name)¶

如果给定的名称是全小写，则将其转换为后端的区分大小写标识符。

此方法仅在方言定义 requires_name_normalize=True 时使用。

attribute sqlalchemy.engine.default.DefaultDialect.div_is_floordiv: bool = True¶: 目标数据库将 / 除法运算符视为“向下取整除法”。

method sqlalchemy.engine.default.DefaultDialect.do_begin(dbapi_connection)¶

提供 connection.begin() 的实现，给定一个 DB-API 连接。

DBAPI 没有专门的“begin”方法，并且预计事务是隐式的。此钩子提供给那些可能需要这方面额外帮助的 DBAPI。

参数:: dbapi_connection¶ – 一个 DBAPI 连接，通常在 ConnectionFairy 中代理。

method sqlalchemy.engine.default.DefaultDialect.do_begin_twophase(connection: Connection, xid: Any) → None¶

继承自 Dialect 的 Dialect.do_begin_twophase() 方法

在给定的连接上开始两阶段事务。

参数:

connection¶ – 一个 Connection。
xid¶ – xid

method sqlalchemy.engine.default.DefaultDialect.do_close(dbapi_connection)¶

提供 connection.close() 的实现，给定一个 DB-API 连接。

此钩子由 Pool 在连接从池中分离或被返回到超出池正常容量时调用。

method sqlalchemy.engine.default.DefaultDialect.do_commit(dbapi_connection)¶

提供 connection.commit() 的实现，给定一个 DB-API 连接。

参数:: dbapi_connection¶ – 一个 DBAPI 连接，通常在 ConnectionFairy 中代理。

method sqlalchemy.engine.default.DefaultDialect.do_commit_twophase(connection: Connection, xid: Any, is_prepared: bool = True, recover: bool = False) → None¶

继承自 Dialect 的 Dialect.do_commit_twophase() 方法

在给定的连接上提交两阶段事务。

参数:

connection¶ – 一个 Connection。
xid¶ – xid
is_prepared¶ – 是否已调用 TwoPhaseTransaction.prepare()。
recover¶ – 如果传递了恢复标志。

method sqlalchemy.engine.default.DefaultDialect.do_execute(cursor, statement, parameters, context=None)¶: 提供 cursor.execute(statement, parameters) 的实现。

method sqlalchemy.engine.default.DefaultDialect.do_execute_no_params(cursor, statement, context=None)¶

提供 cursor.execute(statement) 的实现。

参数集合不应发送。

method sqlalchemy.engine.default.DefaultDialect.do_executemany(cursor, statement, parameters, context=None)¶: 提供 cursor.executemany(statement, parameters) 的实现。

method sqlalchemy.engine.default.DefaultDialect.do_ping(dbapi_connection: DBAPIConnection) → bool¶: ping DBAPI 连接，如果连接可用则返回 True。

method sqlalchemy.engine.default.DefaultDialect.do_prepare_twophase(connection: Connection, xid: Any) → None¶

继承自 Dialect 的 Dialect.do_prepare_twophase() 方法

在给定连接上准备一个两阶段事务。

参数:

connection¶ – 一个 Connection。
xid¶ – xid

method sqlalchemy.engine.default.DefaultDialect.do_recover_twophase(connection: Connection) → List[Any]¶

继承自 Dialect 的 Dialect.do_recover_twophase() 方法

恢复给定连接上未提交的已准备好的两阶段事务标识符列表。

参数:: connection¶ – 一个 Connection。

method sqlalchemy.engine.default.DefaultDialect.do_release_savepoint(connection, name)¶

在连接上释放命名保存点。

参数:

connection¶ – 一个 Connection。
name¶ – 保存点名称。

method sqlalchemy.engine.default.DefaultDialect.do_rollback(dbapi_connection)¶

提供 connection.rollback() 的实现，给定一个 DB-API 连接。

参数:: dbapi_connection¶ – 一个 DBAPI 连接，通常代理在 ConnectionFairy 中。

method sqlalchemy.engine.default.DefaultDialect.do_rollback_to_savepoint(connection, name)¶

将连接回滚到命名的保存点。

参数:

connection¶ – 一个 Connection。
name¶ – 保存点名称。

method sqlalchemy.engine.default.DefaultDialect.do_rollback_twophase(connection: Connection, xid: Any, is_prepared: bool = True, recover: bool = False) → None¶

继承自 Dialect.do_rollback_twophase() 方法 Dialect

回滚给定连接上的两阶段事务。

参数:

connection¶ – 一个 Connection.
xid¶ – xid
is_prepared¶ – 是否调用了 TwoPhaseTransaction.prepare().
recover¶ – 如果传递了 recover 标志。

方法 sqlalchemy.engine.default.DefaultDialect.do_savepoint(connection, name)¶

创建具有给定名称的保存点。

参数:

connection¶ – 一个 Connection.
name¶ – 保存点名称。

方法 sqlalchemy.engine.default.DefaultDialect.do_set_input_sizes(cursor: DBAPICursor, list_of_tuples: _GenericSetInputSizesType, context: ExecutionContext) → Any¶

继承自 Dialect.do_set_input_sizes() 方法 Dialect

使用适当的参数调用 cursor.setinputsizes() 方法

如果 Dialect.bind_typing 属性设置为 BindTyping.SETINPUTSIZES 值，则会调用此钩子。参数数据以元组列表传递（paramname，dbtype，sqltype），其中 paramname 是语句中参数的键，dbtype 是 DBAPI 数据类型，sqltype 是 SQLAlchemy 类型。元组的顺序是正确的参数顺序。

版本 1.4 中的新功能。

在版本 2.0 中更改： - 通过将 Dialect.bind_typing 设置为 BindTyping.SETINPUTSIZES 来启用 setinputsizes 模式。接受 use_setinputsizes 参数的方言应该相应地设置此值。

方法 sqlalchemy.engine.default.DefaultDialect.do_terminate(dbapi_connection)¶

提供 connection.close() 的实现，该实现尽可能地尝试不阻塞，给定 DBAPI 连接。

在绝大多数情况下，这只是调用 .close()，但是对于某些 asyncio 方言来说，可能会调用不同的 API 特性。

此钩子由 Pool 在回收连接或连接已失效时调用。

在版本 1.4.41 中新添加。

属性 sqlalchemy.engine.default.DefaultDialect.driver: str¶: 方言的 DBAPI 的标识名称

属性 sqlalchemy.engine.default.DefaultDialect.engine_config_types: Mapping[str, Any] = {'echo': <function bool_or_str.<locals>.bool_or_value>, 'echo_pool': <function bool_or_str.<locals>.bool_or_value>, 'future': <function asbool>, 'max_overflow': <function asint>, 'pool_recycle': <function asint>, 'pool_size': <function asint>, 'pool_timeout': <function asint>}¶: 字符串键的映射，这些键可以链接到类型转换函数的引擎配置中。

类方法 sqlalchemy.engine.default.DefaultDialect.engine_created(engine: Engine) → None¶

继承自 Dialect.engine_created() 方法 Dialect

在返回最终 Engine 之前调用的一个便利钩子。

如果方言从 get_dialect_cls() 方法返回了不同的类，则钩子将在这两个类上调用，首先在 get_dialect_cls() 方法返回的方言类上调用，然后在调用该方法的类上调用。

钩子应该由方言和/或包装器用来对引擎或其组件应用特殊事件。特别是，它允许方言包装类应用方言级别的事件。

属性 sqlalchemy.engine.default.DefaultDialect.exclude_set_input_sizes: Set[Any] | None = None¶

DBAPI 类型对象的集合，这些对象应该在自动 cursor.setinputsizes() 调用中排除。

这仅在 bind_typing 为 BindTyping.SET_INPUT_SIZES 时使用

属性 sqlalchemy.engine.default.DefaultDialect.execute_sequence_format¶: 是 tuple 的别名

属性 sqlalchemy.engine.default.DefaultDialect.execution_ctx_cls¶: 是 DefaultExecutionContext 的别名

属性 sqlalchemy.engine.default.DefaultDialect.favor_returning_over_lastrowid: bool = False¶

对于支持 lastrowid 和 RETURNING 插入策略的后端，对于简单的单整型主键插入，优先使用 RETURNING。

在大多数后端上，cursor.lastrowid 的性能往往更高。

属性 sqlalchemy.engine.default.DefaultDialect.full_returning¶: 从版本 2.0 开始弃用: full_returning 已弃用，请使用 insert_returning、update_returning、delete_returning

类方法 sqlalchemy.engine.default.DefaultDialect.get_async_dialect_cls(url: URL) → Type[Dialect]¶

继承自 Dialect.get_async_dialect_cls() 方法 Dialect

给定一个 URL，返回异步引擎将使用的 Dialect。

默认情况下，它是 Dialect.get_dialect_cls() 的别名，只返回 cls。如果方言在相同名称下提供同步和异步版本，例如 psycopg 驱动程序，则可以使用它。

版本 2 中的新功能。

另请参见

Dialect.get_dialect_cls()

方法 sqlalchemy.engine.default.DefaultDialect.get_check_constraints(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedCheckConstraint]¶

继承自 Dialect.get_check_constraints() 方法 Dialect

返回关于 table_name 中检查约束的信息。

给定一个字符串 table_name 和一个可选的字符串 schema，以与 ReflectedCheckConstraint 字典相对应的字典列表形式返回检查约束信息。

这是一个内部方言方法。应用程序应使用 Inspector.get_check_constraints()。

方法 sqlalchemy.engine.default.DefaultDialect.get_columns(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedColumn]¶

继承自 Dialect.get_columns() 方法 Dialect

返回关于 table_name 中列的信息。

给定一个 Connection、一个字符串 table_name 和一个可选的字符串 schema，以与 ReflectedColumn 字典相对应的字典列表形式返回列信息。

这是一个内部方言方法。应用程序应使用 Inspector.get_columns()。

方法 sqlalchemy.engine.default.DefaultDialect.get_default_isolation_level(dbapi_conn)¶

给定一个 DBAPI 连接，返回其隔离级别，或者如果无法检索，则返回默认隔离级别。

可以通过子类覆盖，以便为无法可靠地检索实际隔离级别的数据库提供“回退”隔离级别。

默认情况下，调用 Interfaces.get_isolation_level() 方法，传播任何引发的异常。

版本 1.3.22 中的新功能。

类方法 sqlalchemy.engine.default.DefaultDialect.get_dialect_cls(url: URL) → Type[Dialect]¶

继承自 Dialect.get_dialect_cls() 方法 Dialect

给定一个 URL，返回将使用的 Dialect。

这是一个钩子，允许外部插件通过允许从 URL 中加载插件（基于入口点）并返回要使用的实际方言来提供现有方言周围的功能。

默认情况下，它只返回 cls。

method sqlalchemy.engine.default.DefaultDialect.get_dialect_pool_class(url: URL) → Type[Pool]¶: 返回给定 URL 要使用的 Pool 类。

method sqlalchemy.engine.default.DefaultDialect.get_driver_connection(connection)¶

返回由外部驱动程序包返回的连接对象。

对于使用符合 DBAPI 的驱动程序的普通方言，此调用将只返回作为参数传递的 connection。对于改为调整非 DBAPI 兼容驱动程序的方言，例如在调整 asyncio 驱动程序时，此调用将返回驱动程序返回的连接类对象。

新版 1.4.24 中的新增功能。

method sqlalchemy.engine.default.DefaultDialect.get_foreign_keys(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedForeignKeyConstraint]¶

继承自 Dialect.get_foreign_keys() 方法 of Dialect

返回有关 table_name 中外键的信息。

给定一个 Connection、字符串 table_name 以及可选的字符串 schema，返回外键信息，以与 ReflectedForeignKeyConstraint 字典对应的字典列表形式。

这是一个内部方言方法。应用程序应使用 Inspector.get_foreign_keys()。

method sqlalchemy.engine.default.DefaultDialect.get_indexes(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedIndex]¶

继承自 Dialect.get_indexes() 方法 of Dialect

返回有关 table_name 中索引的信息。

给定一个 Connection、字符串 table_name 以及可选的字符串 schema，返回索引信息，以与 ReflectedIndex 字典对应的字典列表形式。

这是一个内部方言方法。应用程序应使用 Inspector.get_indexes().

method sqlalchemy.engine.default.DefaultDialect.get_isolation_level(dbapi_connection: DBAPIConnection) → Literal['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED', 'READ UNCOMMITTED', 'AUTOCOMMIT']¶

继承自 Dialect.get_isolation_level() 方法 of Dialect

给定一个 DBAPI 连接，返回其隔离级别。

在使用 Connection 对象时，可以使用 Connection.connection 访问器获取相应的 DBAPI 连接。

请注意，这是一个方言级别的方法，用作 Connection 和 Engine 隔离级别功能实现的一部分；对于大多数典型用例，应优先使用这些 API。

另请参见

Connection.get_isolation_level() - 查看当前级别

Connection.default_isolation_level - 查看默认级别

Connection.execution_options.isolation_level - 设置每个 Connection 隔离级别

create_engine.isolation_level - 设置每个 Engine 隔离级别

method sqlalchemy.engine.default.DefaultDialect.get_isolation_level_values(dbapi_conn: DBAPIConnection) → List[Literal['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED', 'READ UNCOMMITTED', 'AUTOCOMMIT']]¶

继承自 Dialect.get_isolation_level_values() 方法 of Dialect

返回此方言接受的字符串隔离级别名称序列。

可用名称应使用以下约定

使用大写名称。隔离级别方法将接受小写名称，但这些名称将在传递给方言之前被规范化为大写。
单独的词语应该用空格隔开，而不是下划线，例如 REPEATABLE READ。隔离级别名称将在传递给方言之前将下划线转换为空格。
如果后端支持四个标准隔离级别的名称，则这些名称应为 READ UNCOMMITTED READ COMMITTED, REPEATABLE READ, SERIALIZABLE
如果方言支持自动提交选项，则应使用隔离级别名称 AUTOCOMMIT 提供。
其他隔离模式也可能存在，前提是它们以大写字母命名并使用空格而不是下划线。

此函数用于使默认方言可以检查给定的隔离级别参数是否有效，否则会引发 ArgumentError。

一个 DBAPI 连接被传递给该方法，在方言需要查询连接本身以确定此列表的极不可能的情况下，但预计大多数后端将返回一个硬编码的值列表。如果方言支持“AUTOCOMMIT”，则该值也应存在于返回的序列中。

默认情况下，该方法会引发 NotImplementedError。如果方言没有实现此方法，则默认方言不会在将给定的隔离级别值传递给 Dialect.set_isolation_level() 方法之前对其进行任何检查。这是为了允许与可能尚未实现此方法的第三方方言向后兼容。

版本 2.0 中新增。

method sqlalchemy.engine.default.DefaultDialect.get_materialized_view_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

继承自 Dialect.get_materialized_view_names() 方法 Dialect

返回数据库中所有可用的物化视图名称列表。

这是一个内部方言方法。应用程序应该使用 Inspector.get_materialized_view_names()。

参数:

schema¶ –

要查询的模式名称，如果它不是默认模式。

版本 2.0 中新增。

method sqlalchemy.engine.default.DefaultDialect.get_multi_check_constraints(connection, **kw)¶

返回给定 schema 中所有表中的检查约束的信息。

这是一个内部方言方法。应用程序应该使用 Inspector.get_multi_check_constraints().

注意