核心内构件

优质

小牛编辑

185浏览

2023-12-01

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

Object Name	Description
AdaptedConnection	适配的连接对象的接口，以支持DBAPI协议。
Compiled	表示已编译的SQL或DDL表达式。
DDLCompiler
DefaultDialect	方言默认实现
DefaultExecutionContext
Dialect	定义特定数据库和DB-API组合的行为。
ExecutionContext	对应于单个执行的方言的信使对象。
GenericTypeCompiler
Identified
IdentifierPreparer	根据选项处理标识符的引用和大小写折叠。
SQLCompiler	默认实现 `Compiled` .
StrSQLCompiler	A `SQLCompiler` 允许少量非标准SQL功能呈现为字符串值的子类。

class sqlalchemy.engine.Compiled(dialect, statement, schema_translate_map=None, render_schema_translate=False, compile_kwargs={})¶

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

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

method sqlalchemy.engine.Compiled.__init__(dialect, statement, schema_translate_map=None, render_schema_translate=False, compile_kwargs={})¶

构建新的 Compiled 对象。

参数

dialect¶ -- Dialect 编译。
statement¶ -- ClauseElement 编译。
schema_translate_map¶ -- 在形成结果SQL时要翻译的架构名称字典。版本已添加：：1.1..参阅：模式名称的翻译
compile_kwargs¶ -- 将传递给初始呼叫的其他Kwarg Compiled.process() .

attribute sqlalchemy.engine.Compiled.compile_state = None¶

可选的 CompileState 对象，该对象维护编译器使用的附加状态。

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

1.4 新版功能.

method sqlalchemy.engine.Compiled.construct_params(params=None, extracted_parameters=None)¶

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

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

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

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

attribute sqlalchemy.engine.Compiled.sql_compiler¶

返回能够处理SQL表达式的已编译。

如果这个编译器是一个，它可能只返回“self”。

class sqlalchemy.sql.compiler.DDLCompiler(dialect, statement, schema_translate_map=None, render_schema_translate=False, compile_kwargs={})¶

类签名

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

method sqlalchemy.sql.compiler.DDLCompiler.__init__(dialect, statement, schema_translate_map=None, render_schema_translate=False, compile_kwargs={})¶

inherited from the sqlalchemy.sql.compiler.Compiled.__init__ method of Compiled

构建新的 Compiled 对象。

参数

dialect¶ -- Dialect 编译。
statement¶ -- ClauseElement 编译。
schema_translate_map¶ -- 在形成结果SQL时要翻译的架构名称字典。版本已添加：：1.1..参阅：模式名称的翻译
compile_kwargs¶ -- 将传递给初始呼叫的其他Kwarg Compiled.process() .

method sqlalchemy.sql.compiler.DDLCompiler.construct_params(params=None, extracted_parameters=None)¶

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

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

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

attribute sqlalchemy.sql.compiler.DDLCompiler.params¶

inherited from the Compiled.params attribute of Compiled

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

attribute sqlalchemy.sql.compiler.DDLCompiler.sql_compiler¶

class sqlalchemy.engine.default.DefaultDialect(convert_unicode=False, encoding='utf-8', paramstyle=None, dbapi=None, implicit_returning=None, case_sensitive=True, supports_native_boolean=None, max_identifier_length=None, label_length=None, compiler_linting=0, server_side_cursors=False, **kwargs)¶

方言默认实现

类签名

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

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 = None¶

各种SQLAlchemy构造的可选参数说明符集，通常是模式项。

要实现，建立为一系列元组，如：

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

如果上述结构建立在PostgreSQL方言上，则 Index 构造现在将接受关键字参数 postgresql_using ， postgresql_where NAD postgresql_ops . 为的构造函数指定的任何其他参数 Index 前缀是 postgresql_ 将提高 ArgumentError .

一种方言，不包括 construct_arguments 成员将不参与参数验证系统。对于这种方言，所有参与构造都接受任何参数名，位于以该方言名为前缀的参数名称空间内。这里的基本原理是，尚未实现此功能的第三方方言继续以旧方式工作。

0.9.2 新版功能.

参见

DialectKWArgs - implementing base class which consumes DefaultDialect.construct_arguments

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

构建与DB-API兼容的连接参数。

给出了一个 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 对象
返回: 元组 (*args, **kwargs) 将传递给 Dialect.connect() 方法。

参见

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.dbapi_exception_translation_map = {}¶

在DBAPI发布的异常实际上没有 __name__ 他们是有联系的。

1.0.5 新版功能.

attribute sqlalchemy.engine.default.DefaultDialect.ddl_compiler¶: alias of sqlalchemy.sql.compiler.DDLCompiler

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

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

此方法仅在方言定义要求u nameu normalize=True时使用。

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

提供 connection.begin() ，给定DB-API连接。

DBAPI没有专用的“begin”方法，并且预期事务是隐式的。这个钩子是为那些在这个领域可能需要额外帮助的DBAPI提供的。

注意 Dialect.do_begin() 除非 Transaction 对象正在使用中。这个 Dialect.do_autocommit() 钩子是为dbapis提供的，当sqlAlchemy Connection 在默认的“自动提交”模式下使用。

参数: dbapi_connection¶ -- DBAPI连接，通常在 ConnectionFairy .

method sqlalchemy.engine.default.DefaultDialect.do_begin_twophase(connection, xid)¶

inherited from the Dialect.do_begin_twophase() method of Dialect

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

参数

connection¶ -- 一 Connection .
xid¶ -- XID

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

提供 connection.close() ，给定DBAPI连接。

这个钩子叫 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, xid, is_prepared=True, recover=False)¶

inherited from the Dialect.do_commit_twophase() method of Dialect

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

参数

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_prepare_twophase(connection, xid)¶

inherited from the Dialect.do_prepare_twophase() method of Dialect

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

参数

connection¶ -- 一 Connection .
xid¶ -- XID

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

inherited from the Dialect.do_recover_twophase() method of Dialect

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

参数: 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, xid, is_prepared=True, recover=False)¶

inherited from the Dialect.do_rollback_twophase() method of Dialect

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

参数

connection¶ -- 一 Connection .
xid¶ -- XID
is_prepared¶ -- 不论是否 TwoPhaseTransaction.prepare() 被叫来。
recover¶ -- 如果传递了恢复标志。

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

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

参数

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

method sqlalchemy.engine.default.DefaultDialect.do_set_input_sizes(cursor, list_of_tuples, context)¶

inherited from the Dialect.do_set_input_sizes() method of Dialect

调用cursor.setinputsizes（）具有适当参数的方法

如果方言。使用“输入大小”标志设置为真。参数数据在元组列表（paramname、dbtype、sqltype）中传递，其中 paramname 是语句中参数的键， dbtype 是DBAPI数据类型，并且 sqltype 是SQLAlchemy类型。元组的顺序是正确的参数顺序。

1.4 新版功能.

method sqlalchemy.engine.default.DefaultDialect.classmethod engine_created(engine)¶

inherited from the Dialect.engine_created() method of Dialect

在返回决赛前调用了一个方便挂钩 Engine .

如果方言返回的类与 get_dialect_cls() 方法，然后在两个类上调用钩子，首先在由 get_dialect_cls() 方法，然后在调用方法的类上。

方言和/或包装机应使用钩子将特殊事件应用于引擎或其组件。特别是，它允许方言包装类应用方言级别的事件。

1.0.3 新版功能.

attribute sqlalchemy.engine.default.DefaultDialect.execute_sequence_format¶: alias of tuple

attribute sqlalchemy.engine.default.DefaultDialect.execution_ctx_cls¶: alias of sqlalchemy.engine.default.DefaultExecutionContext

method sqlalchemy.engine.default.DefaultDialect.get_check_constraints(connection, table_name, schema=None, **kw)¶

inherited from the Dialect.get_check_constraints() method of Dialect

返回有关签入约束的信息 table_name .

给定字符串 table_name 和可选字符串 schema ，将检查约束信息作为具有以下键的dict列表返回：

name -检查约束的名称
sqltext -check约束的SQL表达式
**kw -传递给方言的get_check_constraints（）方法的其他选项。

1.1.0 新版功能.

method sqlalchemy.engine.default.DefaultDialect.get_columns(connection, table_name, schema=None, **kw)¶

inherited from the Dialect.get_columns() method of Dialect

返回有关中列的信息 table_name .

给出了一个 Connection 一个字符串 table_name 和可选字符串 schema ，以字典列表的形式返回列信息，其中包含以下键：

名称

列的名称

类型

[sqlalchemy.types#TypeEngine]

可空的

布尔

违约

列的默认值

自动增量

布尔

序列

形式词典

{姓名str，“start”：int，“increment”：int，“minvalue”：int，: “maxValue”：int，“nominValue”：bool，“nomaxValue”：bool，“cycle”：bool，“cache”：int，“order”：bool_

可能存在其他列属性。

method sqlalchemy.engine.default.DefaultDialect.get_default_isolation_level(dbapi_conn)¶

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

可以由子类重写，以便为不能可靠地检索实际隔离级别的数据库提供“后备”隔离级别。

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

1.3.22 新版功能.

method sqlalchemy.engine.default.DefaultDialect.classmethod get_dialect_cls(url)¶

inherited from the Dialect.get_dialect_cls() method of Dialect

给定一个URL，返回 Dialect 会用到的。

这是一个钩子，它允许外部插件围绕现有方言提供功能，方法是允许基于入口点从URL加载插件，然后插件返回要使用的实际方言。

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

1.0.3 新版功能.

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

返回外部驱动程序包返回的Connection对象。

对于使用符合DBAPI的驱动程序的普通方言，此调用将仅返回 connection 作为参数传递。对于改编不符合DBAPI的驱动程序的方言，比如改编异步驱动程序时，此调用将返回驱动程序返回的类似连接的对象。

1.4.24 新版功能.

method sqlalchemy.engine.default.DefaultDialect.get_foreign_keys(connection, table_name, schema=None, **kw)¶

inherited from the Dialect.get_foreign_keys() method of Dialect

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

给出了一个 Connection 一个字符串 table_name 和可选字符串 schema ，将外键信息作为带有这些键的dict列表返回：

名称: 约束的名称
constrained_columns: 构成外键的列名列表
referred_schema: 引用的架构的名称
referred_table: 引用表的名称
referred_columns: 引用表中与受约束的列对应的列名称列表

method sqlalchemy.engine.default.DefaultDialect.get_indexes(connection, table_name, schema=None, **kw)¶

inherited from the Dialect.get_indexes() method of Dialect

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

给出了一个 Connection 一个字符串 table_name 和可选字符串 schema ，将索引信息作为具有以下键的字典列表返回：

名称: 索引的名称
column_names: 按顺序排列的列名列表
独特的: 布尔

method sqlalchemy.engine.default.DefaultDialect.get_isolation_level(dbapi_conn)¶

inherited from the Dialect.get_isolation_level() method of Dialect

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

使用时 Connection 对象，可以使用 Connection.connection 访问器。

请注意，这是一个方言级别的方法，用作 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_pk_constraint(connection, table_name, schema=None, **kw)¶

inherited from the Dialect.get_pk_constraint() method of Dialect

返回有关表“名称”的主键约束的信息。

给出了一个 Connection 一个字符串 table_name 和可选字符串 schema ，将主键信息作为具有以下键的字典返回：

constrained_columns: 构成主键的列名列表
名称: 主键约束的可选名称。

method sqlalchemy.engine.default.DefaultDialect.get_sequence_names(connection, schema=None, **kw)¶

inherited from the Dialect.get_sequence_names() method of Dialect

返回数据库中所有可用序列名的列表。

参数: schema¶ -- 要查询的架构名称，如果不是默认架构。

1.4 新版功能.

method sqlalchemy.engine.default.DefaultDialect.get_table_comment(connection, table_name, schema=None, **kw)¶

inherited from the Dialect.get_table_comment() method of Dialect

返回由标识的表的“注释” table_name .

给定字符串 table_name 和可选字符串 schema ，将表注释信息作为具有此键的字典返回：

文本: 注释的文本

加薪 NotImplementedError 不支持评论的方言。

1.2 新版功能.

method sqlalchemy.engine.default.DefaultDialect.get_table_names(connection, schema=None, **kw)¶

inherited from the Dialect.get_table_names() method of Dialect

返回表名列表 schema .

method sqlalchemy.engine.default.DefaultDialect.get_temp_table_names(connection, schema=None, **kw)¶

inherited from the Dialect.get_temp_table_names() method of Dialect

如果基础后端支持，则返回给定连接上的临时表名列表。

method sqlalchemy.engine.default.DefaultDialect.get_temp_view_names(connection, schema=None, **kw)¶

inherited from the Dialect.get_temp_view_names() method of Dialect

如果基础后端支持，则返回给定连接上的临时视图名称列表。

method sqlalchemy.engine.default.DefaultDialect.get_unique_constraints(connection, table_name, schema=None, **kw)¶

inherited from the Dialect.get_unique_constraints() method of Dialect

返回有关中唯一约束的信息 table_name .

给定字符串 table_name 和可选字符串 schema ，返回唯一约束信息作为具有以下键的dict列表：

名称: 唯一约束的名称
column_names: 按顺序排列的列名列表
* ＊千瓦: 其他选项传递给方言的get_unique_constraints（）方法。

0.9.0 新版功能.

method sqlalchemy.engine.default.DefaultDialect.get_view_definition(connection, view_name, schema=None, **kw)¶

inherited from the Dialect.get_view_definition() method of Dialect

返回视图定义。

给出了一个 Connection 一个字符串 view_name 和可选字符串 schema ，返回视图定义。

method sqlalchemy.engine.default.DefaultDialect.get_view_names(connection, schema=None, **kw)¶

inherited from the Dialect.get_view_names() method of Dialect

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

参数: schema¶ -- 要查询的架构名称，如果不是默认架构。

method sqlalchemy.engine.default.DefaultDialect.has_index(connection, table_name, index_name, schema=None)¶

检查数据库中是否存在特定的索引名。

给出了一个 Connection 对象，字符串 table_name 和字符串索引名称，如果给定表中给定名称的索引存在，则返回True，否则返回false。

这个 DefaultDialect 根据 Dialect.has_table() 和 Dialect.get_indexes() 方法，但是方言可以实现更高性能的版本。

1.4 新版功能.

method sqlalchemy.engine.default.DefaultDialect.has_sequence(connection, sequence_name, schema=None, **kw)¶

inherited from the Dialect.has_sequence() method of Dialect

检查数据库中是否存在特定序列。

给出了一个 Connection 对象和字符串 sequence_name ，如果给定序列存在于数据库中，则返回true，否则返回false。

method sqlalchemy.engine.default.DefaultDialect.has_table(connection, table_name, schema=None, **kw)¶

inherited from the Dialect.has_table() method of Dialect

对于内部方言使用，请检查数据库中是否存在特定表。

给出了一个 Connection 对象、字符串table_name和可选的架构名称，如果数据库中存在给定表，则返回True，否则返回False。

此方法用作面向公众的 Inspector.has_table() 方法，并且还在内部用于实现方法的“checkfirst”行为，例如 Table.create() 和 MetaData.create_all() 。

注解

此方法由SQLAlChemy在内部使用，并被发布，以便第三方方言可以提供实现。它是 not 用于检查表是否存在的公共API。请使用 Inspector.has_table() 方法。或者，为了传统的交叉兼容性， Engine.has_table() 方法可以使用。

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

在有连接的方言的战略性创建过程中调用。

允许方言根据服务器版本信息或其他属性配置选项。

这里传递的连接是一个具有完整功能的sqlAlchemy连接对象。

应该通过super（）调用基方言的initialize（）方法。

注解

从SQLAlchemy 1.4开始，此方法被调用之前任何 Dialect.on_connect() 称为钩子。

method sqlalchemy.engine.default.DefaultDialect.is_disconnect(e, connection, cursor)¶: 如果给定的db-api错误指示无效连接，则返回true

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

如果检测到给定名称不区分大小写，则将其转换为小写。

此方法仅在方言定义要求u nameu normalize=True时使用。

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

返回设置新创建的DBAPI连接的可调用文件。

callable应该接受一个参数“conn”，即DBAPI连接本身。内部可调用项没有返回值。

例如。：：

class MyDialect(default.DefaultDialect):
    # ...

    def on_connect(self):
        def do_on_connect(connection):
            connection.execute("SET SPECIAL FLAGS etc")

        return do_on_connect

这用于设置每个连接的方言范围选项，如隔离模式、Unicode模式等。

使用 PoolEvents.connect() 事件钩子，然后展开DBAPI连接并将其传递给可调用的。

在 1.4 版更改: on-unuconnect钩子不再为方言的第一个连接调用两次。连接钩子仍然在 Dialect.initialize() 方法。

在 1.4.3 版更改: on_connect挂钩从一个新方法on_connect_url调用，该方法传递用于创建连接参数的URL。如果方言需要用于连接的URL对象来获取附加上下文，则可以实现on_connect_url而不是on_connect。

如果没有返回，则不会生成事件侦听器。

返回: 一个可调用的函数，它接受单个DBAPI连接作为参数，也可以不接受。

参见

Dialect.connect() -允许DBAPI connect() 序列本身被控制。

Dialect.on_connect_url() -取代 Dialect.on_connect() 若要同时接收 URL 上下文中的对象。

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

inherited from the Dialect.on_connect_url() method of Dialect

返回设置新创建的DBAPI连接的可调用文件。

此方法是一个新的挂钩，它取代了 Dialect.on_connect() 方法(当由方言实现时)。当不是由方言实现时，它调用 Dialect.on_connect() 方法，以保持与现有方言的兼容性。没有人反对 Dialect.on_connect() 预期的。

callable应该接受一个参数“conn”，即DBAPI连接本身。内部可调用项没有返回值。

例如。：：

class MyDialect(default.DefaultDialect):
    # ...

    def on_connect_url(self, url):
        def do_on_connect(connection):
            connection.execute("SET SPECIAL FLAGS etc")

        return do_on_connect

这用于设置每个连接的方言范围选项，如隔离模式、Unicode模式等。

此方法不同于 Dialect.on_connect() 因为它被传递给 URL 与连接参数相关的对象。通常，获取此信息的唯一方法是从 Dialect.on_connect() 钩子是看上去的 Engine 但是，此URL对象可能已被插件替换。

注解

的默认实现 Dialect.on_connect_url() 是调用 Dialect.on_connect() 方法。因此，如果方言实现此方法，则 Dialect.on_connect() 方法 将不会被调用 除非压倒一切的方言直接从这里呼唤它。

1.4.3 新版功能: 已添加 Dialect.on_connect_url() 它通常会调用 Dialect.on_connect() 。

参数: url¶ -- 一个 URL 对象，该对象表示 URL 已将其传递给 Dialect.create_connect_args() 方法。
返回: 一个可调用的函数，它接受单个DBAPI连接作为参数，也可以不接受。

参见

Dialect.on_connect()

attribute sqlalchemy.engine.default.DefaultDialect.preparer¶: alias of sqlalchemy.sql.compiler.IdentifierPreparer

method sqlalchemy.engine.default.DefaultDialect.reset_isolation_level(dbapi_conn)¶

给定DBAPI连接，将其隔离恢复为默认值。

请注意，这是一个方言级别的方法，用作 Connection 和 Engine 隔离级设施；对于大多数典型的用例，这些API应该是首选的。

参见

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

Connection.default_isolation_level -查看默认级别

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

create_engine.isolation_level -设置 Engine 隔离级别

attribute sqlalchemy.engine.default.DefaultDialect.returns_unicode_strings = symbol('RETURNS_UNICODE')¶

method sqlalchemy.engine.default.DefaultDialect.set_isolation_level(dbapi_conn, level)¶

inherited from the Dialect.set_isolation_level() method of Dialect

给定DBAPI连接，设置其隔离级别。

请注意，这是一个方言级别的方法，用作 Connection 和 Engine 隔离级设施；对于大多数典型的用例，这些API应该是首选的。

参见

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

Connection.default_isolation_level -查看默认级别

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

create_engine.isolation_level -设置 Engine 隔离级别

attribute sqlalchemy.engine.default.DefaultDialect.statement_compiler¶: alias of sqlalchemy.sql.compiler.SQLCompiler

attribute sqlalchemy.engine.default.DefaultDialect.supports_default_metavalue = False¶: 方言支持插入.值(默认)语法

attribute sqlalchemy.engine.default.DefaultDialect.supports_default_values = False¶: 方言支持插入.默认值语法

attribute sqlalchemy.engine.default.DefaultDialect.supports_empty_insert = True¶: 方言支持INSERT()值()

attribute sqlalchemy.engine.default.DefaultDialect.supports_sane_rowcount_returning¶

如果此方言支持正常行数，则为True，即使正在使用RETURNING。

对于不支持返回的方言，这是 supports_sane_rowcount .

attribute sqlalchemy.engine.default.DefaultDialect.type_compiler¶: alias of sqlalchemy.sql.compiler.GenericTypeCompiler

method sqlalchemy.engine.default.DefaultDialect.type_descriptor(typeobj)¶

提供特定于数据库的 TypeEngine 对象，给定来自类型模块的通用对象。

此方法查找名为 colspecs 作为类或实例级变量，并传递到 adapt_type() .

class sqlalchemy.engine.Dialect¶

定义特定数据库和DB-API组合的行为。

元数据定义、SQL查询生成、执行、结果集处理或数据库之间变化的任何方面都在方言的一般类别下定义。方言充当其他特定于数据库的对象实现（包括ExecutionContext、Compiled、DefaultGenerator和TypeEngine）的工厂。

注解

第三方方言不应分类 Dialect 直接。相反，子类 DefaultDialect 或后代阶级。

所有方言都包含以下属性。还支持许多其他属性：

name

从DBAPI中立的角度识别方言的名称（即“sqlite”）。

driver

标识方言DBAPI的名称

positional

如果此方言的paramStyle是位置的，则为true。

paramstyle

要使用的参数样式（某些DB API支持多个参数样式）。

encoding

用于Unicode的编码类型，通常默认为“utf-8”。

statement_compiler

一 Compiled 用于编译SQL语句的类

ddl_compiler

一 Compiled 用于编译DDL语句的类

server_version_info

包含正在使用的数据库后端版本号的元组。此值仅可用于支持方言，通常在与数据库的初始连接期间填充。

default_schema_name

默认架构的名称。此值仅可用于支持方言，通常在与数据库的初始连接期间填充。

execution_ctx_cls

一 ExecutionContext 用于处理语句执行的类

execute_sequence_format

“tuple”或“list”类型，具体取决于cursor.execute（）接受第二个参数的类型（它们各不相同）。

preparer

一 IdentifierPreparer 用于引用标识符的类。

supports_alter

True 如果数据库支持 ALTER TABLE -仅用于在某些情况下生成外键约束

max_identifier_length

标识符名称的最大长度。

supports_sane_rowcount

指示方言是否正确实现的行数 UPDATE 和 DELETE 声明。

supports_sane_multi_rowcount

指示方言是否正确实现的行数 UPDATE 和 DELETE 通过ExecuteMany执行时的语句。

preexecute_autoincrement_sequences

如果“implicit”主键函数必须单独执行才能获取其值，则为true。这是目前面向PostgreSQL的。

implicit_returning

在插入执行期间使用返回或等效项，以便在一次执行中加载新生成的主键和其他列默认值，然后通过插入的主键可用。如果INSERT语句显式指定了RETURN（），则不使用“隐式”功能，插入的_primary_键将不可用。

colspecs

从sqlacalchemy.types映射到特定于方言类的子类的typeengine类的字典。此字典仅为类级别，不能从方言实例本身访问。

supports_default_values

指示构造 INSERT INTO tablename DEFAULT VALUES 支持

supports_sequences

指示方言是否支持创建序列或类似。

sequences_optional

如果为true，则指示sequence（）构造上的“可选”标志是否应发出不生成创建序列的信号。仅适用于支持序列的方言。目前只允许在指定sequence（）用于其他后端的列上使用postgresql-serial。

supports_native_enum

指示方言是否支持本机枚举构造。这将阻止types.enum在使用该类型时生成check约束。

supports_native_boolean

指示方言是否支持本机布尔构造。这将阻止类型.Boolean在使用该类型时生成检查约束。

dbapi_exception_translation_map

一种名称字典，其中将包含键入备用类名的PEP-249异常的名称（integrityerror、operationalerror等）作为值，以支持DBAPI具有未按其所指命名的异常类（例如integrityerror=myException）的情况。在绝大多数情况下，这本词典是空的。

1.0.5 新版功能.

method sqlalchemy.engine.Dialect.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()

method sqlalchemy.engine.Dialect.create_connect_args(url)¶

构建与DB-API兼容的连接参数。

给出了一个 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 对象
返回: 元组 (*args, **kwargs) 将传递给 Dialect.connect() 方法。

参见

URL.translate_connect_args()

method sqlalchemy.engine.Dialect.create_xid()¶

创建两阶段事务ID。

此ID将传递给do_begin_Twophase（）、do_rollback_Twophase（）、do_commit_Twophase（）。其格式未指定。

method sqlalchemy.engine.Dialect.denormalize_name(name)¶

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

此方法仅在方言定义要求u nameu normalize=True时使用。

method sqlalchemy.engine.Dialect.do_begin(dbapi_connection)¶

提供 connection.begin() ，给定DB-API连接。

DBAPI没有专用的“begin”方法，并且预期事务是隐式的。这个钩子是为那些在这个领域可能需要额外帮助的DBAPI提供的。

参数: dbapi_connection¶ -- DBAPI连接，通常在 ConnectionFairy .

method sqlalchemy.engine.Dialect.do_begin_twophase(connection, xid)¶

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

参数

connection¶ -- 一 Connection .
xid¶ -- XID

method sqlalchemy.engine.Dialect.do_close(dbapi_connection)¶

提供 connection.close() ，给定DBAPI连接。

这个钩子叫 Pool 当连接已从池中断开，或返回的连接超出池的正常容量时。

method sqlalchemy.engine.Dialect.do_commit(dbapi_connection)¶

提供 connection.commit() ，给定DB-API连接。

参数: dbapi_connection¶ -- DBAPI连接，通常在 ConnectionFairy .

method sqlalchemy.engine.Dialect.do_commit_twophase(connection, xid, is_prepared=True, recover=False)¶

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

参数

connection¶ -- 一 Connection .
xid¶ -- XID
is_prepared¶ -- 不论是否 TwoPhaseTransaction.prepare() 被叫来。
recover¶ -- 如果传递了恢复标志。

method sqlalchemy.engine.Dialect.do_execute(cursor, statement, parameters, context=None)¶: 提供 cursor.execute(statement, parameters) .

method sqlalchemy.engine.Dialect.do_execute_no_params(cursor, statement, parameters, context=None)¶

提供 cursor.execute(statement) .

不应发送参数集合。

method sqlalchemy.engine.Dialect.do_executemany(cursor, statement, parameters, context=None)¶: 提供 cursor.executemany(statement, parameters) .

method sqlalchemy.engine.Dialect.do_prepare_twophase(connection, xid)¶

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

参数

connection¶ -- 一 Connection .
xid¶ -- XID

method sqlalchemy.engine.Dialect.do_recover_twophase(connection)¶

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

参数: connection¶ -- 一 Connection .

method sqlalchemy.engine.Dialect.do_release_savepoint(connection, name)¶

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

参数

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

method sqlalchemy.engine.Dialect.do_rollback(dbapi_connection)¶

提供 connection.rollback() ，给定DB-API连接。

参数: dbapi_connection¶ -- DBAPI连接，通常在 ConnectionFairy .

method sqlalchemy.engine.Dialect.do_rollback_to_savepoint(connection, name)¶

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

参数

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

method sqlalchemy.engine.Dialect.do_rollback_twophase(connection, xid, is_prepared=True, recover=False)¶

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

参数

connection¶ -- 一 Connection .
xid¶ -- XID
is_prepared¶ -- 不论是否 TwoPhaseTransaction.prepare() 被叫来。
recover¶ -- 如果传递了恢复标志。

method sqlalchemy.engine.Dialect.do_savepoint(connection, name)¶

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

参数

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

method sqlalchemy.engine.Dialect.do_set_input_sizes(cursor, list_of_tuples, context)¶

调用cursor.setinputsizes（）具有适当参数的方法

1.4 新版功能.

method sqlalchemy.engine.Dialect.classmethod engine_created(engine)¶

在返回决赛前调用了一个方便挂钩 Engine .

如果方言返回的类与 get_dialect_cls() 方法，然后在两个类上调用钩子，首先在由 get_dialect_cls() 方法，然后在调用方法的类上。

方言和/或包装机应使用钩子将特殊事件应用于引擎或其组件。特别是，它允许方言包装类应用方言级别的事件。

1.0.3 新版功能.

method sqlalchemy.engine.Dialect.get_check_constraints(connection, table_name, schema=None, **kw)¶

返回有关签入约束的信息 table_name .

给定字符串 table_name 和可选字符串 schema ，将检查约束信息作为具有以下键的dict列表返回：

name -检查约束的名称
sqltext -check约束的SQL表达式
**kw -传递给方言的get_check_constraints（）方法的其他选项。

1.1.0 新版功能.

method sqlalchemy.engine.Dialect.get_columns(connection, table_name, schema=None, **kw)¶

返回有关中列的信息 table_name .

给出了一个 Connection 一个字符串 table_name 和可选字符串 schema ，以字典列表的形式返回列信息，其中包含以下键：

名称

列的名称

类型

[sqlalchemy.types#TypeEngine]

可空的

布尔

违约

列的默认值

自动增量

布尔

序列

形式词典

{姓名str，“start”：int，“increment”：int，“minvalue”：int，: “maxValue”：int，“nominValue”：bool，“nomaxValue”：bool，“cycle”：bool，“cache”：int，“order”：bool_

可能存在其他列属性。

method sqlalchemy.engine.Dialect.get_default_isolation_level(dbapi_conn)¶

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

此方法可能只引发NotImplementedError和 不得引发任何其他异常 ，因为它在第一次连接时隐式使用。

该方法 必须返回值 用于支持隔离级别设置的方言，因为此级别在更改每个连接的隔离级别时将恢复到该级别。

该方法默认使用 Dialect.get_isolation_level() 方法，除非被方言重写。

1.3.22 新版功能.

method sqlalchemy.engine.Dialect.classmethod get_dialect_cls(url)¶

给定一个URL，返回 Dialect 会用到的。

这是一个钩子，它允许外部插件围绕现有方言提供功能，方法是允许基于入口点从URL加载插件，然后插件返回要使用的实际方言。

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

1.0.3 新版功能.

method sqlalchemy.engine.Dialect.get_driver_connection(connection)¶

返回外部驱动程序包返回的Connection对象。

1.4.24 新版功能.

method sqlalchemy.engine.Dialect.get_foreign_keys(connection, table_name, schema=None, **kw)¶

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

给出了一个 Connection 一个字符串 table_name 和可选字符串 schema ，将外键信息作为带有这些键的dict列表返回：

名称: 约束的名称
constrained_columns: 构成外键的列名列表
referred_schema: 引用的架构的名称
referred_table: 引用表的名称
referred_columns: 引用表中与受约束的列对应的列名称列表

method sqlalchemy.engine.Dialect.get_indexes(connection, table_name, schema=None, **kw)¶

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

给出了一个 Connection 一个字符串 table_name 和可选字符串 schema ，将索引信息作为具有以下键的字典列表返回：

名称: 索引的名称
column_names: 按顺序排列的列名列表
独特的: 布尔

method sqlalchemy.engine.Dialect.get_isolation_level(dbapi_conn)¶

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

使用时 Connection 对象，可以使用 Connection.connection 访问器。

请注意，这是一个方言级别的方法，用作 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.Dialect.get_pk_constraint(connection, table_name, schema=None, **kw)¶

返回有关表“名称”的主键约束的信息。

给出了一个 Connection 一个字符串 table_name 和可选字符串 schema ，将主键信息作为具有以下键的字典返回：

constrained_columns: 构成主键的列名列表
名称: 主键约束的可选名称。

method sqlalchemy.engine.Dialect.get_sequence_names(connection, schema=None, **kw)¶

返回数据库中所有可用序列名的列表。

参数: schema¶ -- 要查询的架构名称，如果不是默认架构。

1.4 新版功能.

method sqlalchemy.engine.Dialect.get_table_comment(connection, table_name, schema=None, **kw)¶

返回由标识的表的“注释” table_name .

给定字符串 table_name 和可选字符串 schema ，将表注释信息作为具有此键的字典返回：

文本: 注释的文本

加薪 NotImplementedError 不支持评论的方言。

1.2 新版功能.

method sqlalchemy.engine.Dialect.get_table_names(connection, schema=None, **kw)¶: 返回表名列表 schema .

method sqlalchemy.engine.Dialect.get_temp_table_names(connection, schema=None, **kw)¶: 如果基础后端支持，则返回给定连接上的临时表名列表。

method sqlalchemy.engine.Dialect.get_temp_view_names(connection, schema=None, **kw)¶: 如果基础后端支持，则返回给定连接上的临时视图名称列表。

method sqlalchemy.engine.Dialect.get_unique_constraints(connection, table_name, schema=None, **kw)¶

返回有关中唯一约束的信息 table_name .

给定字符串 table_name 和可选字符串 schema ，返回唯一约束信息作为具有以下键的dict列表：

名称: 唯一约束的名称
column_names: 按顺序排列的列名列表
* ＊千瓦: 其他选项传递给方言的get_unique_constraints（）方法。

0.9.0 新版功能.

method sqlalchemy.engine.Dialect.get_view_definition(connection, view_name, schema=None, **kw)¶

返回视图定义。

给出了一个 Connection 一个字符串 view_name 和可选字符串 schema ，返回视图定义。

method sqlalchemy.engine.Dialect.get_view_names(connection, schema=None, **kw)¶

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

参数: schema¶ -- 要查询的架构名称，如果不是默认架构。

method sqlalchemy.engine.Dialect.has_index(connection, table_name, index_name, schema=None)¶

检查数据库中是否存在特定的索引名。

给出了一个 Connection 对象，字符串 table_name 和字符串索引名称，如果给定表中给定名称的索引存在，则返回True，否则返回false。

这个 DefaultDialect 根据 Dialect.has_table() 和 Dialect.get_indexes() 方法，但是方言可以实现更高性能的版本。

1.4 新版功能.

method sqlalchemy.engine.Dialect.has_sequence(connection, sequence_name, schema=None, **kw)¶

检查数据库中是否存在特定序列。

给出了一个 Connection 对象和字符串 sequence_name ，如果给定序列存在于数据库中，则返回true，否则返回false。

method sqlalchemy.engine.Dialect.has_table(connection, table_name, schema=None, **kw)¶

对于内部方言使用，请检查数据库中是否存在特定表。

给出了一个 Connection 对象、字符串table_name和可选的架构名称，如果数据库中存在给定表，则返回True，否则返回False。

此方法用作面向公众的 Inspector.has_table() 方法，并且还在内部用于实现方法的“checkfirst”行为，例如 Table.create() 和 MetaData.create_all() 。

注解

method sqlalchemy.engine.Dialect.initialize(connection)¶

在有连接的方言的战略性创建过程中调用。

允许方言根据服务器版本信息或其他属性配置选项。

这里传递的连接是一个具有完整功能的sqlAlchemy连接对象。

应该通过super（）调用基方言的initialize（）方法。

注解

从SQLAlchemy 1.4开始，此方法被调用之前任何 Dialect.on_connect() 称为钩子。

method sqlalchemy.engine.Dialect.is_disconnect(e, connection, cursor)¶: 如果给定的db-api错误指示无效连接，则返回true

method sqlalchemy.engine.Dialect.classmethod load_provisioning()¶

设置条款.py这个方言的模块。

对于包括条款.py模块，此方法应启动该进程。

典型的实现方式是：

@classmethod
def load_provisioning(cls):
    __import__("mydialect.provision")

默认方法假定一个名为 provision.py 在当前方言的所属包中，基于 __module__ 属性：

@classmethod
def load_provisioning(cls):
    package = ".".join(cls.__module__.split(".")[0:-1])
    try:
        __import__(package + ".provision")
    except ImportError:
        pass

1.3.14 新版功能.

method sqlalchemy.engine.Dialect.normalize_name(name)¶

如果检测到给定名称不区分大小写，则将其转换为小写。

此方法仅在方言定义要求u nameu normalize=True时使用。

method sqlalchemy.engine.Dialect.on_connect()¶

返回设置新创建的DBAPI连接的可调用文件。

callable应该接受一个参数“conn”，即DBAPI连接本身。内部可调用项没有返回值。

例如。：：

class MyDialect(default.DefaultDialect):
    # ...

    def on_connect(self):
        def do_on_connect(connection):
            connection.execute("SET SPECIAL FLAGS etc")

        return do_on_connect

这用于设置每个连接的方言范围选项，如隔离模式、Unicode模式等。

使用 PoolEvents.connect() 事件钩子，然后展开DBAPI连接并将其传递给可调用的。

在 1.4 版更改: on-unuconnect钩子不再为方言的第一个连接调用两次。连接钩子仍然在 Dialect.initialize() 方法。

如果没有返回，则不会生成事件侦听器。

返回: 一个可调用的函数，它接受单个DBAPI连接作为参数，也可以不接受。

参见

Dialect.connect() -允许DBAPI connect() 序列本身被控制。

Dialect.on_connect_url() -取代 Dialect.on_connect() 若要同时接收 URL 上下文中的对象。

method sqlalchemy.engine.Dialect.on_connect_url(url)¶

返回设置新创建的DBAPI连接的可调用文件。

callable应该接受一个参数“conn”，即DBAPI连接本身。内部可调用项没有返回值。

例如。：：

class MyDialect(default.DefaultDialect):
    # ...

    def on_connect_url(self, url):
        def do_on_connect(connection):
            connection.execute("SET SPECIAL FLAGS etc")

        return do_on_connect

这用于设置每个连接的方言范围选项，如隔离模式、Unicode模式等。

注解

1.4.3 新版功能: 已添加 Dialect.on_connect_url() 它通常会调用 Dialect.on_connect() 。

参数: url¶ -- 一个 URL 对象，该对象表示 URL 已将其传递给 Dialect.create_connect_args() 方法。
返回: 一个可调用的函数，它接受单个DBAPI连接作为参数，也可以不接受。

参见

Dialect.on_connect()

method sqlalchemy.engine.Dialect.reset_isolation_level(dbapi_conn)¶

给定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.Dialect.set_isolation_level(dbapi_conn, level)¶

给定DBAPI连接，设置其隔离级别。

请注意，这是一个方言级别的方法，用作 Connection 和 Engine 隔离级设施；对于大多数典型的用例，这些API应该是首选的。

参见

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

Connection.default_isolation_level -查看默认级别

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

create_engine.isolation_level -设置 Engine 隔离级别

attribute sqlalchemy.engine.Dialect.supports_statement_cache = True¶

指示此方言是否支持缓存。

所有与语句缓存兼容的方言都应该在支持它的每个方言类和子类上直接将此标志设置为True。SQLAlChemy在使用语句缓存之前测试此标志是否在每个方言子类上本地存在。这是为了为尚未完全测试为符合SQL语句缓存的旧方言或新方言提供安全性。

1.4.5 新版功能.

参见

第三方方言的缓存

method sqlalchemy.engine.Dialect.classmethod type_descriptor(typeobj)¶

将泛型类型转换为方言特定类型。

方言类通常使用 adapt_type() 在“类型”模块中执行此操作。

已缓存返回的结果 每方言类 因此不能包含方言实例状态。

class sqlalchemy.engine.default.DefaultExecutionContext¶

类签名

class sqlalchemy.engine.default.DefaultExecutionContext (sqlalchemy.engine.interfaces.ExecutionContext)

method sqlalchemy.engine.default.DefaultExecutionContext.create_cursor()¶

返回从此ExecutionContext的连接生成的新光标。

有些方言可能希望更改connection.cursor（）的行为，例如postgresql，它可能返回pg“server-side”光标。

attribute sqlalchemy.engine.default.DefaultExecutionContext.current_parameters = None¶

应用于当前行的参数字典。

此属性仅在用户定义的默认生成函数的上下文中可用，例如，如中所述上下文相关的默认函数 . 它由一个字典组成，其中包括作为insert或update语句一部分的每个列/值对的条目。字典的键将是每个 Column ，通常与名称同义。

请注意 DefaultExecutionContext.current_parameters 属性不适用于 Insert.values() 方法。这个 DefaultExecutionContext.get_current_parameters() 应首选方法。

参见

DefaultExecutionContext.get_current_parameters()

上下文相关的默认函数

method sqlalchemy.engine.default.DefaultExecutionContext.get_current_parameters(isolate_multiinsert_groups=True)¶

返回应用于当前行的参数字典。

此方法只能在用户定义的默认生成函数的上下文中使用，例如，如中所述上下文相关的默认函数 . 调用时，将返回一个字典，其中包含作为insert或update语句一部分的每个列/值对的条目。字典的键将是每个 Column ，通常与名称同义。

参数: isolate_multiinsert_groups=True¶ -- 指示使用创建的多值插入构造 Insert.values() 应该通过只返回当前列默认调用本地的参数子集来处理。什么时候？ False ，返回语句的原始参数，包括多值插入时使用的命名约定。

1.2 新版功能: 补充 DefaultExecutionContext.get_current_parameters() 它提供了比现有功能更多的功能 DefaultExecutionContext.current_parameters 属性。

参见

DefaultExecutionContext.current_parameters

上下文相关的默认函数

method sqlalchemy.engine.default.DefaultExecutionContext.get_lastrowid()¶

插入后返回self.cursor.lastrowid或等效项。

这可能涉及调用特殊的光标函数、在光标上发出一个新的select（或一个新的），或返回在post_exec（）中计算的存储值。

只对支持“隐式”主键生成、将preexecute_autoincrement_sequences设置为false以及没有显式ID值绑定到语句的方言调用此函数。

对于使用lastrowid概念的方言，需要为INSERT语句调用一次函数，该语句需要返回最后插入的主键。在这些情况下，它直接在 ExecutionContext.post_exec() .

method sqlalchemy.engine.default.DefaultExecutionContext.get_out_parameter_values(names)¶

从游标返回一系列OUT参数值。

对于支持OUT参数的方言，当存在 SQLCompiler 具有 SQLCompiler.has_out_parameters 标志设置。如果语句本身有 BindParameter 具有 .isoutparam 使用的标志集 SQLCompiler.visit_bindparam() 方法。如果方言编译器生成 BindParameter 对象与 .isoutparam 不由处理的集合 SQLCompiler.visit_bindparam() ，它应该显式设置此标志。

为每个绑定参数呈现的名称列表将传递给该方法。然后，该方法应返回与参数对象列表相对应的一系列值。与以前的SQLAlchemy版本不同，这些值可以是 原始值 执行上下文将根据自编译.binds并更新值。处理后的字典将通过 .out_parameters 结果对象上的集合。注意，作为SQL2.1的多个转换部分的结果。

1.4 新版功能: -增加的 ExecutionContext.get_out_parameter_values() ，它由 DefaultExecutionContext 当有 BindParameter 对象 .isoutparam 标志设置。这将取代在现在删除的参数中设置参数的做法 get_result_proxy() 方法。

参见

ExecutionContext.get_result_cursor_strategy()

method sqlalchemy.engine.default.DefaultExecutionContext.get_result_processor(type_, colname, coltype)¶

返回cursor.description中存在的给定类型的“结果处理器”。

这有一个默认实现，方言可以为上下文敏感的结果类型处理重写该实现。

method sqlalchemy.engine.default.DefaultExecutionContext.handle_dbapi_exception(e)¶: 接收执行、结果获取等时发生的DBAPI异常。

method sqlalchemy.engine.default.DefaultExecutionContext.lastrow_has_defaults()¶: 如果最后一个插入或更新行包含内联或数据库端默认值，则返回true。

method sqlalchemy.engine.default.DefaultExecutionContext.post_exec()¶

在已编译语句执行后调用。

如果已编译语句传递到此ExecutionContext，则 last_insert_ids ， last_inserted_params 等。此方法完成后，数据成员应可用。

method sqlalchemy.engine.default.DefaultExecutionContext.pre_exec()¶

在执行已编译语句之前调用。

如果已编译语句传递到此ExecutionContext，则 statement 和 parameters 此语句完成后，必须初始化DataMembers。

method sqlalchemy.engine.default.DefaultExecutionContext.should_autocommit_text(statement)¶: 分析给定的文本语句，如果引用“可提交”语句，则返回true

class sqlalchemy.engine.ExecutionContext¶

对应于单个执行的方言的信使对象。

ExecutionContext应具有以下数据成员：

连接: 连接对象，默认值生成器可以自由使用该对象来执行SQL。此连接应引用根连接的相同基础连接/事务性资源。
root_connection: 连接对象，它是此ExecutionContext的源。此连接可能具有close_，其结果设置为true，在这种情况下，它只能使用一次。
方言: 创建此ExecutionContext的方言。
光标: 从连接处获取的DB-API光标，
编译的: 如果传递给构造函数，则执行sqlAlchemy.engine.base.compiled对象，
陈述: 要执行的语句的字符串版本。传递给构造函数，或者必须在pre_exec（）完成时从sql.compiled对象创建。
参数: 绑定传递给execute（）方法的参数。对于编译语句，这是一个字典或字典列表。对于文本语句，其格式应适合方言的参数样式（即非位置的dict或dict列表，位置的列表或列表/元组列表）。
IS插入: 如果语句是insert，则为true。
ISUPDATE: 如果语句是更新的，则为true。
should_autocommit: 如果该语句是“可提交”语句，则为true。
prefetch_cols: 为其触发客户端默认值的列对象列表。适用于插入和更新。
postfetch_cols: 为其触发服务器端默认值或内联SQL表达式值的列对象列表。适用于插入和更新。

method sqlalchemy.engine.ExecutionContext.create_cursor()¶

返回从此ExecutionContext的连接生成的新光标。

有些方言可能希望更改connection.cursor（）的行为，例如postgresql，它可能返回pg“server-side”光标。

method sqlalchemy.engine.ExecutionContext.get_out_parameter_values(out_param_names)¶

从游标返回一系列OUT参数值。

参见

ExecutionContext.get_result_cursor_strategy()

method sqlalchemy.engine.ExecutionContext.get_result_cursor_strategy(result)¶

返回给定结果对象的结果游标策略。

此方法由 DefaultDialect 只有在必须对游标采取一些特殊步骤的情况下实现方言才需要，例如从游标的其他元素生成假结果，或预缓冲游标的结果。

默认实现的简化版本是：

from sqlalchemy.engine.result import DefaultCursorFetchStrategy

class MyExecutionContext(DefaultExecutionContext):
    def get_result_cursor_strategy(self, result):
        return DefaultCursorFetchStrategy.create(result)

上面， DefaultCursorFetchStrategy 将应用于结果对象。对于从可能关闭的游标预缓冲的结果，实现可以是：

from sqlalchemy.engine.result import (
    FullyBufferedCursorFetchStrategy
)

class MyExecutionContext(DefaultExecutionContext):
    _pre_buffered_result = None

    def pre_exec(self):
        if self.special_condition_prebuffer_cursor():
            self._pre_buffered_result = (
                self.cursor.description,
                self.cursor.fetchall()
            )

    def get_result_cursor_strategy(self, result):
        if self._pre_buffered_result:
            description, cursor_buffer = self._pre_buffered_result
            return (
                FullyBufferedCursorFetchStrategy.
                    create_from_buffer(
                        result, description, cursor_buffer
                )
            )
        else:
            return DefaultCursorFetchStrategy.create(result)

此方法替代了以前没有完全文档化的方法 get_result_proxy() 方法。

1.4 新版功能: -result对象现在根据可插入的“strategy”对象解释游标结果，该对象由 ExecutionContext 通过 ExecutionContext.get_result_cursor_strategy() 方法。

参见

ExecutionContext.get_out_parameter_values()

method sqlalchemy.engine.ExecutionContext.get_rowcount()¶

返回DBAPI cursor.rowcount 值，或者在某些情况下是解释值。

见 CursorResult.rowcount 有关详细信息。

method sqlalchemy.engine.ExecutionContext.handle_dbapi_exception(e)¶: 接收执行、结果获取等时发生的DBAPI异常。

method sqlalchemy.engine.ExecutionContext.lastrow_has_defaults()¶: 如果最后一个插入或更新行包含内联或数据库端默认值，则返回true。

method sqlalchemy.engine.ExecutionContext.post_exec()¶

在已编译语句执行后调用。

如果已编译语句传递到此ExecutionContext，则 last_insert_ids ， last_inserted_params 等。此方法完成后，数据成员应可用。

method sqlalchemy.engine.ExecutionContext.pre_exec()¶

在执行已编译语句之前调用。

如果已编译语句传递到此ExecutionContext，则 statement 和 parameters 此语句完成后，必须初始化DataMembers。

method sqlalchemy.engine.ExecutionContext.should_autocommit_text(statement)¶: 分析给定的文本语句，如果引用“可提交”语句，则返回true

class sqlalchemy.sql.compiler.GenericTypeCompiler(dialect)¶

类签名

class sqlalchemy.sql.compiler.GenericTypeCompiler (sqlalchemy.sql.compiler.TypeCompiler)

class sqlalchemy.log.Identified¶

class sqlalchemy.sql.compiler.IdentifierPreparer(dialect, initial_quote='"', final_quote=None, escape_quote='"', quote_case_sensitive_collations=True, omit_schema=False)¶

根据选项处理标识符的引用和大小写折叠。

method sqlalchemy.sql.compiler.IdentifierPreparer.__init__(dialect, initial_quote='"', final_quote=None, escape_quote='"', quote_case_sensitive_collations=True, omit_schema=False)¶

构建新的 IdentifierPreparer 对象。

initial_quote: 以分隔标识符开头的字符。
final_quote: 以分隔标识符结尾的字符。默认为 initial_quote .
omit_schema: 防止预挂架构名称。对于不支持模式的数据库很有用。

method sqlalchemy.sql.compiler.IdentifierPreparer.format_column(column, use_table=False, name=None, table_name=None, use_schema=False, anon_map=None)¶: 准备带引号的列名。

method sqlalchemy.sql.compiler.IdentifierPreparer.format_label_name(name, anon_map=None)¶: 准备带引号的列名。

method sqlalchemy.sql.compiler.IdentifierPreparer.format_schema(name)¶: 准备引用的架构名称。

method sqlalchemy.sql.compiler.IdentifierPreparer.format_table(table, use_schema=True, name=None)¶: 准备带引号的表和架构名称。

method sqlalchemy.sql.compiler.IdentifierPreparer.format_table_seq(table, use_schema=True)¶: 将表名和架构格式化为元组。

method sqlalchemy.sql.compiler.IdentifierPreparer.quote(ident, force=None)¶

有条件地引用标识符。

如果标识符是保留字、包含必要的引号字符或是 quoted_name 其中包括 quote 设置为 True .

子类可以重写此项，为标识符名称提供与数据库相关的引用行为。

参数

ident¶ -- 字符串识别码
force¶ -- 未使用的已弃用：：0.9 IdentifierPreparer.quote.force 参数已弃用，将在将来的版本中删除。此标志对 IdentifierPreparer.quote() 方法；请参阅 quoted_name .

method sqlalchemy.sql.compiler.IdentifierPreparer.quote_identifier(value)¶

引用标识符。

子类应重写此项以提供与数据库相关的引用行为。

method sqlalchemy.sql.compiler.IdentifierPreparer.quote_schema(schema, force=None)¶

有条件地引用架构名称。

如果名称是保留字、包含必要的引号字符或是 quoted_name 其中包括 quote 设置为 True .

子类可以重写此内容，为模式名提供与数据库相关的引用行为。

参数

schema¶ -- 字符串架构名称
force¶ -- 未使用的已弃用：：0.9 IdentifierPreparer.quote_schema.force 参数已弃用，将在将来的版本中删除。此标志对 IdentifierPreparer.quote() 方法；请参阅 quoted_name .

attribute sqlalchemy.sql.compiler.IdentifierPreparer.schema_for_object = operator.attrgetter('schema')¶

返回对象的.schema属性。

对于默认的IdentifierPreparer，对象的架构始终是“.schema”属性的值。如果准备器被替换为具有非空的schema_translate_映射，则“.schema”属性的值将呈现为一个符号，该符号将从映射后编译转换为真实的架构名称。

method sqlalchemy.sql.compiler.IdentifierPreparer.unformat_identifiers(identifiers)¶: 将类似“schema.table.column”的字符串解包到组件中。

method sqlalchemy.sql.compiler.IdentifierPreparer.validate_sql_phrase(element, reg)¶

关键字序列筛选器。

用于表示关键字序列的元素的筛选器，如“初始”、“初始延迟”等。不应出现特殊字符。

1.3 新版功能.

class sqlalchemy.sql.compiler.SQLCompiler(dialect, statement, cache_key=None, column_keys=None, for_executemany=False, linting=symbol('NO_LINTING'), **kwargs)¶

默认实现 Compiled .

编译 ClauseElement 对象转换为SQL字符串。

类签名

class sqlalchemy.sql.compiler.SQLCompiler (sqlalchemy.sql.compiler.Compiled)

method sqlalchemy.sql.compiler.SQLCompiler.__init__(dialect, statement, cache_key=None, column_keys=None, for_executemany=False, linting=symbol('NO_LINTING'), **kwargs)¶

构建新的 SQLCompiler 对象。

参数

dialect¶ -- Dialect 被使用
statement¶ -- ClauseElement 编译
column_keys¶ -- 要编译成INSERT或UPDATE语句的列名列表。
for_executemany¶ -- INSERT/UPDATE语句是否应预期它们将以“ecutemany”样式调用，这可能会影响语句预期如何返回默认值和自动增量/序列等的值。根据使用的后端和驱动程序的不同，可能会禁用对检索这些值的支持，这意味着可能会内联呈现SQL表达式，可能不会呈现返回，等等。
kwargs¶ -- 超类要使用的其他关键字参数。

attribute sqlalchemy.sql.compiler.SQLCompiler.ansi_bind_rules = False¶: SQL 92不允许在select的columns子句中使用bind参数，也不允许类似这样的不明确表达式？=？”。如果目标驱动程序/db强制执行此项，则编译器子类可以将此标志设置为false。

method sqlalchemy.sql.compiler.SQLCompiler.construct_params(params=None, _group_number=None, _check=True, extracted_parameters=None)¶: 返回绑定参数键和值的字典

attribute sqlalchemy.sql.compiler.SQLCompiler.current_executable¶

返回正在编译的当前“可执行文件”。

这是当前 Select ， Insert ， Update ， Delete ， CompoundSelect 正在编译的对象。特别是它被分配给 self.stack 元素列表。

当像上面这样的语句被编译时，它通常也被分配给 .statement 的属性 Compiler 对象。但是，所有的SQL构造最终都是可嵌套的，并且此属性永远不应该由 visit_ 方法，因为它既不能保证被赋值，也不能保证与正在编译的当前语句相对应。

1.3.21 新版功能: 为了与以前的版本兼容，请使用以下方法：

statement = getattr(self, "current_executable", False)
if statement is False:
    statement = self.stack[-1]["selectable"]

对于1.4及更高版本，请确保仅使用当前的可执行文件；格式为“self.堆栈“可能会改变。

method sqlalchemy.sql.compiler.SQLCompiler.default_from()¶

当select语句没有froms且不追加froms子句时调用。

让甲骨文有机会 FROM DUAL 到字符串输出。

method sqlalchemy.sql.compiler.SQLCompiler.delete_extra_from_clause(update_stmt, from_table, extra_froms, from_hints, **kw)¶

提供一个钩子来重写delete..from子句的生成。

这可用于实现删除。例如，使用。

mysql和mssql会覆盖这个。

attribute sqlalchemy.sql.compiler.SQLCompiler.escaped_bind_names = {}¶: 在参数字典中查找时必须转换为原始名称的绑定参数名称的后期转义。

method sqlalchemy.sql.compiler.SQLCompiler.get_select_precolumns(select, **kw)¶: 在构建时调用 SELECT 语句，位置在列列表之前。

method sqlalchemy.sql.compiler.SQLCompiler.group_by_clause(select, **kw)¶: 允许方言自定义分组方式。

attribute sqlalchemy.sql.compiler.SQLCompiler.has_out_parameters = False¶: 如果为True，则存在设置了isoutparam标志的bindparam（）对象。

attribute sqlalchemy.sql.compiler.SQLCompiler.insert_single_values_expr = None¶

当使用值表达式内的一组参数编译INSERT时，将在此处指定字符串，在这里可以将字符串用于INSERT批处理方案以重写值表达式。

1.3.8 新版功能.

attribute sqlalchemy.sql.compiler.SQLCompiler.isdelete = False¶: 类级别默认值，可以在实例级别设置，以定义此编译实例是否表示插入/更新/删除

attribute sqlalchemy.sql.compiler.SQLCompiler.literal_execute_params = frozenset({})¶: 在语句执行时呈现为文本值的bindparameter对象。

method sqlalchemy.sql.compiler.SQLCompiler.order_by_clause(select, **kw)¶: 允许方言自定义排序方式。

attribute sqlalchemy.sql.compiler.SQLCompiler.params¶: 对于存在的值，返回嵌入到此编译对象中的绑定参数字典。

attribute sqlalchemy.sql.compiler.SQLCompiler.post_compile_params = frozenset({})¶: 在语句执行时呈现为绑定参数占位符的bindparameter对象。

attribute sqlalchemy.sql.compiler.SQLCompiler.postfetch_lastrowid = False¶: 如果为True，并且在insert中使用cursor.lastrowid填充result.inserted_主键.

method sqlalchemy.sql.compiler.SQLCompiler.render_literal_value(value, type_)¶

将绑定参数的值呈现为带引号的文本。

这用于不接受目标驱动程序/数据库上绑定参数的语句部分。

这应该通过使用DBAPI的引用服务的子类实现。

attribute sqlalchemy.sql.compiler.SQLCompiler.render_table_with_column_in_update_from = False¶: 设置为true classwide以指示多表更新语句中的set子句应使用表名限定列（即仅限mysql）

attribute sqlalchemy.sql.compiler.SQLCompiler.returning = None¶: 如果语句是CRUD，则保留列的“返回”集合，并隐式或显式定义返回列

attribute sqlalchemy.sql.compiler.SQLCompiler.returning_precedes_values = False¶: 设置为true classwide以在values或where子句（即mssql）之前生成返回子句

attribute sqlalchemy.sql.compiler.SQLCompiler.sql_compiler¶

attribute sqlalchemy.sql.compiler.SQLCompiler.translate_select_structure = None¶: 如果没有 None ，应该是一个接受 (select_stmt, **kw) 并返回一个select对象。这主要用于结构变更，以适应限制/偏移方案

method sqlalchemy.sql.compiler.SQLCompiler.update_from_clause(update_stmt, from_table, extra_froms, from_hints, **kw)¶

提供一个钩子来重写update..from子句的生成。

mysql和mssql会覆盖这个。

method sqlalchemy.sql.compiler.SQLCompiler.update_limit_clause(update_stmt)¶: 为MySQL提供一个钩子，以便向更新添加限制

method sqlalchemy.sql.compiler.SQLCompiler.update_tables_clause(update_stmt, from_table, extra_froms, **kw)¶

提供一个钩子来重写update语句中的初始table子句。

MySQL会覆盖这个。

class sqlalchemy.sql.compiler.StrSQLCompiler(dialect, statement, cache_key=None, column_keys=None, for_executemany=False, linting=symbol('NO_LINTING'), **kwargs)¶

A SQLCompiler 允许少量非标准SQL功能呈现为字符串值的子类。

这个 StrSQLCompiler 每当直接对核心表达式元素进行字符串化而不调用 ClauseElement.compile() 方法。它可以呈现一组有限的非标准SQL构造来帮助基本的字符串化，但是对于更实质性的定制或特定于方言的SQL构造，有必要利用 ClauseElement.compile() 直接。

参见

如何将SQL表达式呈现为字符串（可能是内联绑定参数）？

类签名

class sqlalchemy.sql.compiler.StrSQLCompiler (sqlalchemy.sql.compiler.SQLCompiler)

method sqlalchemy.sql.compiler.StrSQLCompiler.delete_extra_from_clause(update_stmt, from_table, extra_froms, from_hints, **kw)¶

提供一个钩子来重写delete..from子句的生成。

这可用于实现删除。例如，使用。

mysql和mssql会覆盖这个。

method sqlalchemy.sql.compiler.StrSQLCompiler.update_from_clause(update_stmt, from_table, extra_froms, from_hints, **kw)¶

提供一个钩子来重写update..from子句的生成。

mysql和mssql会覆盖这个。

class sqlalchemy.engine.AdaptedConnection¶

适配的连接对象的接口，以支持DBAPI协议。

由异步语言使用，以在驱动程序提供的异步连接/光标API之上提供同步样式的PEP-249外观。

1.4.24 新版功能.

attribute sqlalchemy.engine.AdaptedConnection.driver_connection¶: 驱动程序在连接后返回的连接对象。