可选择的基础构造函数¶

顶层的“FROM子句”和“SELECT”构造函数。

function sqlalchemy.sql.expression.except_(*selects, **kwargs)¶

返回一 EXCEPT 多个可选择的。

返回的对象是 CompoundSelect .

参数

• *selects¶ -- 一览表 Select 实例。

• **kwargs¶ -- 可用关键字参数与 select() .

function sqlalchemy.sql.expression.except_all(*selects, **kwargs)¶

返回一 EXCEPT ALL 多个可选择的。

返回的对象是 CompoundSelect .

参数

• *selects¶ -- 一览表 Select 实例。

• **kwargs¶ -- 可用关键字参数与 select() .

function sqlalchemy.sql.expression.exists(*args, **kwargs)¶

构建新的 Exists 构造。

这个 exists() 可以自行调用以生成 Exists 构造，它将接受简单的WHERE条件：

exists_criteria = exists().where(table1.c.col1 == table2.c.col2)

但是，为了在构造SELECT时具有更大的灵活性 Select 构造可以转换为 Exists ，最方便的方法是利用 SelectBase.exists() 方法：

exists_criteria = (
    select(table2.c.col2).
    where(table1.c.col1 == table2.c.col2).
    exists()
)

EXISTS条件随后在封闭的SELECT中使用：

stmt = select(table1.c.col1).where(exists_criteria)

上述声明的格式如下：

SELECT col1 FROM table1 WHERE EXISTS
(SELECT table2.col2 FROM table2 WHERE table2.col2 = table1.col1)

参见

存在的子查询 -在 2.0 style 辅导的。

function sqlalchemy.sql.expression.intersect(*selects, **kwargs)¶

返回一 INTERSECT 多个可选择的。

返回的对象是 CompoundSelect .

参数

• *selects¶ -- 一览表 Select 实例。

• **kwargs¶ -- 可用关键字参数与 select() .

function sqlalchemy.sql.expression.intersect_all(*selects, **kwargs)¶

返回一 INTERSECT ALL 多个可选择的。

返回的对象是 CompoundSelect .

参数

• *selects¶ -- 一览表 Select 实例。

• **kwargs¶ -- 可用关键字参数与 select() .

function sqlalchemy.sql.expression.select(*args, **kw)¶

创建一个 Select 使用1.x或2.0构造函数样式。

有关旧调用样式，请参阅 Select.create_legacy_select() . 如果传递的第一个参数是Python序列或存在关键字参数，则使用此样式。

2.0 新版功能: - the select() construct is the same construct as the one returned by select(), except that the function only accepts the "columns clause" entities up front; the rest of the state of the SELECT should be built up using generative methods.

类似功能也可通过 FromClause.select() 任意方法 FromClause .

参见

选择 -核心教程说明 select() .

参数

*entities¶ -- 要从中选择的实体。对于核心用法，这通常是一系列 ColumnElement 和/或 FromClause 将构成结果语句的columns子句的对象。对于那些属于 FromClause （典型地 Table 或 Alias 对象） FromClause.c 提取集合以形成 ColumnElement 物体。此参数也将接受 TextClause 构造，以及ORM映射类。

function sqlalchemy.sql.expression.table(name, *columns, **kw)¶

产生新的 TableClause .

返回的对象是的实例 TableClause 表示模式级别的“语法”部分 Table 对象。它可以用来构造轻量级的表构造。

在 1.0.0 版更改: table() 现在可以从平原进口了 sqlalchemy 与任何其他SQL元素一样。

参数

• name¶ -- 表的名称。

• columns¶ -- 收藏 column() 构造。

• schema¶ -- 此表的架构名称。。版本添加：：1.3.18 table() 现在可以接受 schema 争论。

function sqlalchemy.sql.expression.union(*selects, **kwargs)¶

返回A UNION 多个可选择的。

返回的对象是 CompoundSelect .

类似的 union() 方法可用于所有 FromClause 子类。

参数

• *selects¶ -- 一览表 Select 实例。

• **kwargs¶ -- 可用关键字参数与 select() .

function sqlalchemy.sql.expression.union_all(*selects, **kwargs)¶

返回A UNION ALL 多个可选择的。

返回的对象是 CompoundSelect .

类似的 union_all() 方法可用于所有 FromClause 子类。

参数

• *selects¶ -- 一览表 Select 实例。

• **kwargs¶ -- 可用关键字参数与 select() .

function sqlalchemy.sql.expression.values(*columns, **kw)¶

构建一个 Values 构造。

的列表达式和实际数据 Values 分两个步骤给出。构造函数接收列表达式通常如下所示 column() 构造，然后数据通过 Values.data() 方法作为一个列表，可以多次调用以添加更多数据，例如：

from sqlalchemy import column
from sqlalchemy import values

value_expr = values(
    column('id', Integer),
    column('name', String),
    name="my_values"
).data(
    [(1, 'name1'), (2, 'name2'), (3, 'name3')]
)

参数

• *columns¶ -- 列表达式，通常由 column() 物体。

• name¶ -- 此值构造的名称。如果省略，VALUES构造将在SQL表达式中未命名。不同的后端在这里可能有不同的要求。

• literal_binds¶ -- 默认为False。是否在SQL输出中以内联方式呈现数据值，而不是使用绑定参数。

可选修改器构造函数¶

这里列出的函数通常作为 FromClause 和 Selectable 元素，例如 alias() 函数通常通过 FromClause.alias() 方法。

function sqlalchemy.sql.expression.alias(selectable, name=None, flat=False)¶

返回一 Alias 对象。

安 Alias 表示任何 FromClause 在SQL中分配了备用名称，通常使用 AS 生成时的子句，例如 SELECT * FROM table AS aliasname .

类似功能可通过 FromClause.alias() 方法适用于所有 FromClause 子类。从 select() 函数 SelectBase.alias() 方法返回 Alias 或表示带括号的命名子查询的类似对象。

当一个 Alias 创建自 Table 对象，这具有将表呈现为 tablename AS aliasname 在select语句中。

为了 select() 对象，其效果是创建一个命名的子查询，即 (select ...) AS aliasname .

这个 name 参数是可选的，并提供在呈现的SQL中使用的名称。如果为空，将在编译时确定地生成一个“匿名”名称。确定性意味着该名称对于同一语句中使用的其他构造是唯一的，并且对于同一语句对象的每个连续编译也将是相同的名称。

参数

• selectable¶ -- 任何 FromClause 子类，如表、select语句等。

• name¶ -- 要指定为别名的字符串名称。如果 None ，将在编译时确定地生成名称。

• flat¶ -- 如果给定的可选对象是 Join -见 Join.alias() 有关详细信息。

function sqlalchemy.sql.expression.cte(selectable, name=None, recursive=False)¶

返回一个新的 CTE 或公用表表达式实例。

请看 HasCTE.cte() 有关CTE用法的详细信息。

function sqlalchemy.sql.expression.join(left, right, onclause=None, isouter=False, full=False)¶

产生一个 Join 对象，给定两个 FromClause 表达。

例如。：：

j = join(user_table, address_table,
         user_table.c.id == address_table.c.user_id)
stmt = select(user_table).select_from(j)

将沿着以下行发出SQL:：

SELECT user.id, user.name FROM user
JOIN address ON user.id = address.user_id

如果有类似的功能 FromClause 对象（例如 Table ）使用 FromClause.join() 方法。

参数

• left¶ -- 连接的左侧。

• right¶ -- 连接的右侧；这是任何 FromClause 对象，如 Table 对象，也可以是可选的兼容对象，如ORM映射类。

• onclause¶ -- 表示联接的ON子句的SQL表达式。如果留在 None ， FromClause.join() 将尝试基于外键关系联接两个表。

• isouter¶ -- 如果为true，则呈现左侧外部联接，而不是联接。

• full¶ -- 如果为true，则呈现完整的外部联接，而不是联接。…添加的版本：1.1

参见

FromClause.join() -方法窗体，基于给定的左侧。

Join -生成的对象的类型。

function sqlalchemy.sql.expression.lateral(selectable, name=None)¶

返回A Lateral 对象。

Lateral 是一个 Alias 子类，表示应用了横向关键字的子查询。

横向子查询的特殊行为是它出现在封闭select的from子句中，但可能与该select的其他from子句相关联。这是子查询的一种特殊情况，只有少量后端支持，目前是更新的PostgreSQL版本。

1.1 新版功能.

参见

横向相关 -使用概述。

function sqlalchemy.sql.expression.outerjoin(left, right, onclause=None, full=False)¶

返回一 OUTER JOIN 子句元素。

返回的对象是 Join .

类似功能也可通过 FromClause.outerjoin() 任意方法 FromClause .

参数

• left¶ -- 连接的左侧。

• right¶ -- 连接的右侧。

• onclause¶ -- 的可选标准 ON 子句，则派生自在左键和右键之间建立的外键关系，否则。

要将连接链结在一起，请使用 FromClause.join() 或 FromClause.outerjoin() 结果的方法 Join 对象。

function sqlalchemy.sql.expression.tablesample(selectable, sampling, name=None, seed=None)¶

返回A TableSample 对象。

TableSample 是一个 Alias 表示应用了tablesample子句的表的子类。 tablesample() 也可以从 FromClause 类通过 FromClause.tablesample() 方法。

tablesample子句允许从表中随机选择大约百分比的行。它支持多种采样方法，最常见的是伯努利和系统。

例如。：：

from sqlalchemy import func

selectable = people.tablesample(
            func.bernoulli(1),
            name='alias',
            seed=func.random())
stmt = select(selectable.c.people_id)

假设 people 用柱 people_id ，上面的语句将呈现为：

SELECT alias.people_id FROM
people AS alias TABLESAMPLE bernoulli(:bernoulli_1)
REPEATABLE (random())

1.1 新版功能.

参数

• sampling¶ -- 一 float 0到100之间的百分比或 Function .

• name¶ -- 可选别名

• seed¶ -- 任何实值SQL表达式。如有规定，还应提供可重复的子条款。

可选课程文档¶

这里的类是使用中列出的构造函数生成的 可选择的基础构造函数 和 可选修改器构造函数 .

class sqlalchemy.sql.expression.Alias(*arg, **kw)¶

表示表或可选别名（as）。

表示别名，通常应用于SQL语句中使用 AS 关键字（或在某些数据库（如Oracle）上不带关键字）。

此对象是由 alias() 模块级功能以及 FromClause.alias() 方法适用于所有 FromClause 子类。

参见

FromClause.alias()

类签名

class sqlalchemy.sql.expression.Alias (sqlalchemy.sql.roles.DMLTableRole, sqlalchemy.sql.expression.AliasedReturnsRows)

class sqlalchemy.sql.expression.AliasedReturnsRows(*arg, **kw)¶

表、子查询和其他可选项别名的基类。

类签名

class sqlalchemy.sql.expression.AliasedReturnsRows (sqlalchemy.sql.expression.NoInit, sqlalchemy.sql.expression.FromClause)

attribute sqlalchemy.sql.expression.AliasedReturnsRows.description¶

method sqlalchemy.sql.expression.AliasedReturnsRows.is_derived_from(fromclause)¶

返回 True 如果这样 FromClause 是从给定的 FromClause .

例如，表的别名是从该表派生的。

attribute sqlalchemy.sql.expression.AliasedReturnsRows.original¶

方言的遗产别名.original.

class sqlalchemy.sql.expression.CompoundSelect(keyword, *selects, **kwargs)¶

构成 UNION ， UNION ALL ，以及其他基于SELECT的set操作。

参见

union()

union_all()

intersect()

intersect_all()

except()

except_all()

类签名

class sqlalchemy.sql.expression.CompoundSelect (sqlalchemy.sql.expression.HasCompileState, sqlalchemy.sql.expression.GenerativeSelect)

attribute sqlalchemy.sql.expression.CompoundSelect.bind¶

返回 Engine 或 Connection 对此 Executable 是绑定的，如果未找到，则为无。

1.4 版后已移除: 这个 Executable.bind 属性在SQLAlchemy的1.x系列中被认为是遗留的，将在2.0中删除。从SQLAlchemy 2.0开始，绑定的元数据将被删除。（SQLAlchemy 2.0的背景： 迁移到Alchemy ）

attribute sqlalchemy.sql.expression.CompoundSelect.selected_columns¶

A ColumnCollection 表示此SELECT语句或类似构造在其结果集中返回的列，而不包括 TextClause 构造。

对于一个 CompoundSelect , the CompoundSelect.selected_columns 属性返回set操作中的一系列语句中包含的第一个SELECT语句的选定列。

参见

Select.selected_columns

1.4 新版功能.

method sqlalchemy.sql.expression.CompoundSelect.self_group(against=None)¶

对此应用“分组” ClauseElement .

此方法被子类重写以返回“grouping”构造，即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组，以及 select() 当放入另一个的FROM子句时构造 select() . （请注意，通常应使用 Select.alias() 方法，因为许多平台都需要命名嵌套的select语句）。

当表达式组合在一起时，应用 self_group() 是自动的-最终用户代码不需要直接使用这个方法。请注意，sqlachemy的子句构造将运算符优先考虑在内，因此可能不需要括号，例如，在类似这样的表达式中 x OR (y AND z) -优先于或。

底座 self_group() 方法 ClauseElement 只需返回自我。

class sqlalchemy.sql.expression.CTE(*arg, **kw)¶

表示公用表表达式。

这个 CTE 对象是使用 SelectBase.cte() 方法。不常用的语法也允许使用 HasCTE.cte() 方法存在于 DML 构造，例如 Insert ， Update 和 Delete . 见 HasCTE.cte() 方法获取有关CTE的使用详细信息。

参见

子查询和CTE -在2.0教程中

HasCTE.cte() -调用样式示例

类签名

class sqlalchemy.sql.expression.CTE (sqlalchemy.sql.roles.DMLTableRole, sqlalchemy.sql.roles.IsCTERole, sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.HasPrefixes, sqlalchemy.sql.expression.HasSuffixes, sqlalchemy.sql.expression.AliasedReturnsRows)

method sqlalchemy.sql.expression.CTE.alias(name=None, flat=False)¶

返回一 Alias 其中 CTE .

此方法是 FromClause.alias() 方法。

参见

使用别名和子查询

alias()

class sqlalchemy.sql.expression.Executable¶

马克A ClauseElement 作为支持执行。

Executable 是所有“语句”类型对象的超类，包括 select() ， delete() ， update() ， insert() ， text() .

类签名

class sqlalchemy.sql.expression.Executable (sqlalchemy.sql.roles.StatementRole, sqlalchemy.sql.expression.Generative)

attribute sqlalchemy.sql.expression.Executable.bind¶

返回 Engine 或 Connection 对此 Executable 是绑定的，如果未找到，则为无。

1.4 版后已移除: 这个 Executable.bind 属性在SQLAlchemy的1.x系列中被认为是遗留的，将在2.0中删除。从SQLAlchemy 2.0开始，绑定的元数据将被删除。（SQLAlchemy 2.0的背景： 迁移到Alchemy ）

这是一个遍历，它在本地进行检查，然后在关联对象的“from”子句之间进行检查，直到找到绑定的引擎或连接为止。

method sqlalchemy.sql.expression.Executable.execute(*multiparams, **params)¶

编译并执行此 Executable .

1.4 版后已移除: 这个 Executable.execute() 方法在SQLAlchemy的1.x系列中被认为是遗留的，并将在2.0中删除。SQLAlchemy 2.0中的所有语句执行都由 Connection.execute() 方法 Connection ，或在ORM中 Session.execute() 方法 Session . （SQLAlchemy 2.0的背景： 迁移到Alchemy ）

method sqlalchemy.sql.expression.Executable.execution_options(**kw)¶

为在执行期间生效的语句设置非SQL选项。

可以对每个语句或每个语句设置执行选项。 Connection 基础。另外， Engine 和ORM Query 对象提供对执行选项的访问，这些执行选项反过来在连接时进行配置。

这个 execution_options() 方法是生成的。返回此语句的新实例，其中包含以下选项：

statement = select(table.c.x, table.c.y)
statement = statement.execution_options(autocommit=True)

请注意，只有可能的执行选项的一个子集可以应用于语句-这些选项包括“autocommit”和“stream_results”，但不包括“isolation_level”或“compiled_cache”。见 Connection.execution_options() 完整的选项列表。

参见

Connection.execution_options()

Query.execution_options()

Executable.get_execution_options()

method sqlalchemy.sql.expression.Executable.get_execution_options()¶

获取将在执行期间生效的非SQL选项。

1.3 新版功能.

参见

Executable.execution_options()

method sqlalchemy.sql.expression.Executable.options(*options)¶

将选项应用于此语句。

一般来说，options是可以由SQL编译器解释语句的任何种类的Python对象。这些选项可以由特定方言或特定种类的编译器使用。

最常见的一种选项是ORM级别的选项，它将“急切加载”和其他加载行为应用于ORM查询。然而，从理论上讲，期权可以用于许多其他目的。

有关特定类型语句的特定类型选项的背景信息，请参阅这些选项对象的文档。

在 1.4 版更改: -增加的 Generative.options() 对语句对象进行核心化，以实现统一的Core/ORM查询功能。

参见

延迟的列加载程序查询选项 -指特定于ORM查询用法的选项

与加载程序选项的关系加载 -指特定于ORM查询用法的选项

method sqlalchemy.sql.expression.Executable.scalar(*multiparams, **params)¶

编译并执行此 Executable ，返回结果的标量表示。

1.4 版后已移除: 这个 Executable.scalar() 方法被认为是SQLAlChemy 1.x系列的遗留方法，将在2.0中删除。SQLAlChemy 2.0中的标量执行由 Connection.scalar() 一种方法 Connection ，或在ORM中由 Session.scalar() 一种方法 Session 。(有关SQLAlChemy 2.0的背景信息位于： 迁移到Alchemy )

class sqlalchemy.sql.expression.Exists(*args, **kwargs)¶

代表 EXISTS 条款。

见 exists() 关于用法的描述。

类签名

class sqlalchemy.sql.expression.Exists (sqlalchemy.sql.expression.UnaryExpression)

method sqlalchemy.sql.expression.Exists.__init__(*args, **kwargs)¶

构建新的 Exists 对象。

此构造函数被镜像为公共API函数；请参见 sqlalchemy.sql.expression.exists() 完整的用法和参数描述。

method sqlalchemy.sql.expression.Exists.correlate(*fromclause)¶

将关联应用于 Exists .

参见

ScalarSelect.correlate()

method sqlalchemy.sql.expression.Exists.correlate_except(*fromclause)¶

将关联应用于 Exists .

参见

ScalarSelect.correlate_except()

method sqlalchemy.sql.expression.Exists.select(whereclause=None, **kwargs)¶

返回此选项 Exists .

例如。：：

stmt = exists(some_table.c.id).where(some_table.c.id == 5).select()

这将产生一个类似于：

SELECT EXISTS (SELECT id FROM some_table WHERE some_table = :param) AS anon_1

参数

• whereclause¶ -- 调用子句，相当于调用 Select.where() 方法。。已弃用：：1.4 Exists.select().whereclause 参数已弃用，将在版本2.0中删除。请利用 Select.where() 方法将WHERE条件添加到SELECT语句。

• **kwargs¶ -- 其他关键字参数传递给的旧构造函数 Select 描述在 Select.create_legacy_select() . .. 已弃用：：1.4 Exists.select() 方法将不再接受2.0版中的关键字参数。请使用 Select 构造以应用其他修改。

参见

select() -允许任意列列表的通用方法。

method sqlalchemy.sql.expression.Exists.select_from(*froms)¶

返回一个新的 Exists 构造，将给定表达式应用于 Select.select_from() 包含的select语句的方法。

注解

通常最好建立一个 Select 语句，包括所需的WHERE子句，然后使用 SelectBase.exists() 方法生成 Exists 立刻反对。

method sqlalchemy.sql.expression.Exists.where(clause)¶

返回一个新的 exists() 将给定表达式添加到其WHERE子句中，并通过AND（如果有）连接到现有子句。

注解

通常最好建立一个 Select 语句，包括所需的WHERE子句，然后使用 SelectBase.exists() 方法生成 Exists 立刻反对。

class sqlalchemy.sql.expression.FromClause¶

表示可以在 FROM A的子句 SELECT 语句。

最常见的形式 FromClause 是 Table 以及 select() 构造。所有人共同的主要特征 FromClause 对象包括：

• 一 c 集合，它提供对集合的按名称访问 ColumnElement 物体。

• 一 primary_key 属性，它是所有这些属性的集合 ColumnElement 指示 primary_key 旗帜。

• 生成“from”子句的各种派生的方法，包括 FromClause.alias() ， FromClause.join() ， FromClause.select() .

类签名

class sqlalchemy.sql.expression.FromClause (sqlalchemy.sql.roles.AnonymizedFromClauseRole, sqlalchemy.sql.expression.Selectable)

method sqlalchemy.sql.expression.FromClause.alias(name=None, flat=False)¶

返回此的别名 FromClause .

例如。：：

a2 = some_table.alias('a2')

上面的代码创建一个 Alias 对象，可在任何select语句中用作FROM子句。

参见

使用别名和子查询

alias()

attribute sqlalchemy.sql.expression.FromClause.c¶

基于命名的集合 ColumnElement 由此维护的对象 FromClause .

这个 FromClause.c 属性是 FromClause.columns 属性。

返回

一 ColumnCollection

attribute sqlalchemy.sql.expression.FromClause.columns¶

基于命名的集合 ColumnElement 由此维护的对象 FromClause .

这个 columns 或 c 集合，是使用表绑定或其他可选绑定列构造SQL表达式的网关：：

select(mytable).where(mytable.c.somecolumn == 5)

返回

一 ColumnCollection 对象。

attribute sqlalchemy.sql.expression.FromClause.description¶

对此的简要描述 FromClause .

主要用于错误消息格式。

attribute sqlalchemy.sql.expression.FromClause.entity_namespace¶

返回用于SQL表达式中基于名称的访问的命名空间。

这是用于解析“filter_by（）”类型表达式的命名空间，例如：

stmt.filter_by(address='some address')

它默认为 .c 集合，但是在内部可以使用“entity_namespace”注释重写它，以传递其他结果。

attribute sqlalchemy.sql.expression.FromClause.exported_columns¶

A ColumnCollection 它表示此的“导出”列 Selectable .

的“导出”列 FromClause 对象与 FromClause.columns 收集。

1.4 新版功能.

参见

Selectable.exported_columns

SelectBase.exported_columns

attribute sqlalchemy.sql.expression.FromClause.foreign_keys¶

返回 ForeignKey 此FromClause引用的标记对象。

每个人 ForeignKey 是一个 Table -宽度 ForeignKeyConstraint 。

参见

Table.foreign_key_constraints

method sqlalchemy.sql.expression.FromClause.is_derived_from(fromclause)¶

返回 True 如果这样 FromClause 是从给定的 FromClause .

例如，表的别名是从该表派生的。

method sqlalchemy.sql.expression.FromClause.join(right, onclause=None, isouter=False, full=False)¶

返回A Join 由此 FromClause 对另一个 FromClause .

例如。：：

from sqlalchemy import join

j = user_table.join(address_table,
                user_table.c.id == address_table.c.user_id)
stmt = select(user_table).select_from(j)

将沿着以下行发出SQL:：

SELECT user.id, user.name FROM user
JOIN address ON user.id = address.user_id

参数

• right¶ -- 连接的右侧；这是任何 FromClause 对象，如 Table 对象，也可以是可选的兼容对象，如ORM映射类。

• onclause¶ -- 表示联接的ON子句的SQL表达式。如果留在 None ， FromClause.join() 将尝试基于外键关系联接两个表。

• isouter¶ -- 如果为true，则呈现左侧外部联接，而不是联接。

• full¶ -- 如果为true，则呈现完整的外部联接，而不是左外部联接。暗示 FromClause.join.isouter . …添加的版本：1.1

参见

join() -独立函数

Join -生成的对象类型

method sqlalchemy.sql.expression.FromClause.outerjoin(right, onclause=None, full=False)¶

返回A Join 由此 FromClause 对另一个 FromClause ，并将“Isouter”标志设置为true。

例如。：：

from sqlalchemy import outerjoin

j = user_table.outerjoin(address_table,
                user_table.c.id == address_table.c.user_id)

以上相当于：

j = user_table.join(
    address_table,
    user_table.c.id == address_table.c.user_id,
    isouter=True)

参数

• right¶ -- 连接的右侧；这是任何 FromClause 对象，如 Table 对象，也可以是可选的兼容对象，如ORM映射类。

• onclause¶ -- 表示联接的ON子句的SQL表达式。如果留在 None ， FromClause.join() 将尝试基于外键关系联接两个表。

• full¶ -- 如果为true，则呈现完整的外部联接，而不是左外部联接。…添加的版本：1.1

参见

FromClause.join()

Join

attribute sqlalchemy.sql.expression.FromClause.primary_key¶

返回的iterable集合 Column 对象，这些对象构成 _selectable.FromClause .

对于一个 Table 对象，此集合由 PrimaryKeyConstraint 它本身就是 Column 物体。

attribute sqlalchemy.sql.expression.FromClause.schema = None¶

为此定义“schema”属性 FromClause .

这是典型的 None 对于大多数对象，除了 Table ，其中它被视为 Table.schema 争论。

method sqlalchemy.sql.expression.FromClause.select(whereclause=None, **kwargs)¶

返回此选项 FromClause .

例如。：：

stmt = some_table.select().where(some_table.c.id == 5)

参数

• whereclause¶ -- 调用子句，相当于调用 Select.where() 方法。。已弃用：：1.4 FromClause.select().whereclause 参数已弃用，将在版本2.0中删除。请利用 Select.where() 方法将WHERE条件添加到SELECT语句。

• **kwargs¶ -- 其他关键字参数传递给的旧构造函数 Select 描述在 Select.create_legacy_select() .

参见

select() -允许任意列列表的通用方法。

method sqlalchemy.sql.expression.FromClause.table_valued()¶

返回一个 TableValuedColumn 此对象的 FromClause 。

A TableValuedColumn 是一种 ColumnElement 它表示表中的完整行。对此构造的支持依赖于后端，并且由PostgreSQL、Oracle和SQL Server等后端以各种形式支持。

例如。：：

>>> from sqlalchemy import select, column, func, table
>>> a = table("a", column("id"), column("x"), column("y"))
>>> stmt = select(func.row_to_json(a.table_valued()))
>>> print(stmt)
SELECT row_to_json(a) AS row_to_json_1
FROM a

1.4.0b2 新版功能.

参见

使用SQL函数 - in the SQLAlchemy 1.4/2.0教程

method sqlalchemy.sql.expression.FromClause.tablesample(sampling, name=None, seed=None)¶

返回此的TableSample别名 FromClause .

返回值是 TableSample 顶层也提供施工 tablesample() 功能。

1.1 新版功能.

参见

tablesample() -使用指南和参数

class sqlalchemy.sql.expression.GenerativeSelect(_label_style=symbol('LABEL_STYLE_DISAMBIGUATE_ONLY'), use_labels=False, limit=None, offset=None, order_by=None, group_by=None, bind=None)¶

可添加其他元素的select语句的基类。

这是 Select 和 CompoundSelect 其中可以添加order by、group by等元素，并控制列呈现。比较 TextualSelect 当它子类 SelectBase 它也是一个select构造，表示一个固定的文本字符串，在这个级别上不能更改，只能包装为一个子查询。

类签名

class sqlalchemy.sql.expression.GenerativeSelect (sqlalchemy.sql.expression.DeprecatedSelectBaseGenerations, sqlalchemy.sql.expression.SelectBase)

method sqlalchemy.sql.expression.GenerativeSelect.apply_labels()¶

1.4 版后已移除: 这个 GenerativeSelect.apply_labels() 方法被认为是SQLAlChemy 1.x系列的遗留方法，将在2.0中删除。请改用set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL)。(有关SQLAlChemy 2.0的背景信息位于： 迁移到Alchemy )

method sqlalchemy.sql.expression.GenerativeSelect.fetch(count, with_ties=False, percent=False)¶

返回一个新的可选择的，并应用给定的先取条件。

这是一个数值，通常呈现为 FETCH {{FIRST | NEXT}} [ count ] {{ROW | ROWS}} {{ONLY | WITH TIES}} 结果select中的表达式。此功能目前在Oracle、PostgreSQL、MSSQL中实现。

使用 GenerativeSelect.offset() 指定偏移。

注解

这个 GenerativeSelect.fetch() 方法将替换应用的任何子句 GenerativeSelect.limit() .

1.4 新版功能.

参数

• count¶ -- 整数计数参数，或提供整数结果的SQL表达式。什么时候？ percent=True 这将表示要返回的行的百分比，而不是绝对值。通过 None 重置它。

• with_ties¶ -- 什么时候？ True ，WITH TIES选项用于根据 ORDER BY 条款。这个 ORDER BY 在这种情况下可能是强制性的。默认为 False

• percent¶ -- 什么时候？ True ， count 表示要返回的选定行总数的百分比。默认为 False

参见

GenerativeSelect.limit()

GenerativeSelect.offset()

method sqlalchemy.sql.expression.GenerativeSelect.get_label_style()¶

检索当前标签样式。

1.4 新版功能.

method sqlalchemy.sql.expression.GenerativeSelect.group_by(*clauses)¶

返回一个新的可选列表，并应用分组依据条件的给定列表。

例如。：：

stmt = select(table.c.name, func.max(table.c.stat)).\
group_by(table.c.name)

参数

*clauses¶ -- 一系列 ColumnElement 用于生成group by子句的构造。

参见

使用GROUP BY/HAVING聚合函数 - in the SQLAlchemy 1.4/2.0教程

按标签排序或分组 - in the SQLAlchemy 1.4/2.0教程

method sqlalchemy.sql.expression.GenerativeSelect.limit(limit)¶

返回应用给定限制条件的新的可选值。

这是一个数值，通常呈现为 LIMIT 结果选择中的表达式。不支持的后端 LIMIT 将尝试提供类似的功能。

注解

这个 GenerativeSelect.limit() 方法将替换应用的任何子句 GenerativeSelect.fetch() .

在 1.0.0 版更改: - Select.limit() can now accept arbitrary SQL expressions as well as integer values.

参数

limit¶ -- 整数限制参数，或提供整数结果的SQL表达式。通过 None 重置它。

参见

GenerativeSelect.fetch()

GenerativeSelect.offset()

method sqlalchemy.sql.expression.GenerativeSelect.offset(offset)¶

返回一个新的可选择的，并应用给定的偏移标准。

这是一个数值，通常呈现为 OFFSET 结果选择中的表达式。不支持的后端 OFFSET 将尝试提供类似的功能。

在 1.0.0 版更改: - Select.offset() can now accept arbitrary SQL expressions as well as integer values.

参数

offset¶ -- 整数偏移量参数，或提供整数结果的SQL表达式。通过 None 重置它。

参见

GenerativeSelect.limit()

GenerativeSelect.fetch()

method sqlalchemy.sql.expression.GenerativeSelect.order_by(*clauses)¶

返回一个新的可选择的，并应用了ORDER BY条件的给定列表。

例如。：：

stmt = select(table).order_by(table.c.id, table.c.name)

参数

*clauses¶ -- 一系列 ColumnElement 用于生成ORDER BY子句的构造。

参见

排序依据 - in the SQLAlchemy 1.4/2.0教程

按标签排序或分组 - in the SQLAlchemy 1.4/2.0教程

method sqlalchemy.sql.expression.GenerativeSelect.set_label_style(style)¶

返回具有指定标签样式的新可选对象。

有三种“标签样式”可用， LABEL_STYLE_DISAMBIGUATE_ONLY ， LABEL_STYLE_TABLENAME_PLUS_COL ，以及 LABEL_STYLE_NONE 。默认样式为 LABEL_STYLE_TABLENAME_PLUS_COL 。

在现代SQLAlChemy中，通常不需要更改标签样式，因为通过使用 ColumnElement.label() 方法。在过去的版本中， LABEL_STYLE_TABLENAME_PLUS_COL 用于从不同的表、别名或子查询中消除同名列的歧义；较新的 LABEL_STYLE_DISAMBIGUATE_ONLY 现在，标签仅应用于与现有名称冲突的名称，因此此标签的影响最小。

消除歧义的基本原理主要是使所有列表达式都可以从给定的 FromClause.c 创建子查询时的集合。

1.4 新版功能: -The GenerativeSelect.set_label_style() 方法取代了以前的组合 .apply_labels() ， .with_labels() 和 use_labels=True 方法和/或参数。

参见

LABEL_STYLE_DISAMBIGUATE_ONLY

LABEL_STYLE_TABLENAME_PLUS_COL

LABEL_STYLE_NONE

LABEL_STYLE_DEFAULT

method sqlalchemy.sql.expression.GenerativeSelect.slice(start, stop)¶

基于切片对此语句应用限制/偏移量。

开始和停止索引的行为类似于python内置的参数 range() 功能。此方法提供了使用 LIMIT/OFFSET 获取查询切片。

例如：

stmt = select(User).order_by(User).id.slice(1, 3)

呈现为

SELECT users.id AS users_id,
       users.name AS users_name
FROM users ORDER BY users.id
LIMIT ? OFFSET ?
(2, 1)

注解

这个 GenerativeSelect.slice() 方法将替换应用的任何子句 GenerativeSelect.fetch() .

1.4 新版功能: 增加了 GenerativeSelect.slice() 从ORM中推广的方法。

参见

GenerativeSelect.limit()

GenerativeSelect.offset()

GenerativeSelect.fetch()

method sqlalchemy.sql.expression.GenerativeSelect.with_for_update(nowait=False, read=False, of=None, skip_locked=False, key_share=False)¶

指定一个 FOR UPDATE 此条款 GenerativeSelect .

例如。：：

stmt = select(table).with_for_update(nowait=True)

在PostgreSQL或Oracle这样的数据库上，上面的语句将呈现如下：

SELECT table.a, table.b FROM table FOR UPDATE NOWAIT

在其他后端， nowait 选项被忽略，将生成：：

SELECT table.a, table.b FROM table FOR UPDATE

当不带参数调用时，该语句将以后缀呈现 FOR UPDATE . 然后可以提供其他参数，以允许常见的特定于数据库的变量。

参数

• nowait¶ -- 布尔值；将呈现 FOR UPDATE NOWAIT 关于Oracle和PostgreSQL方言。

• read¶ -- 布尔值；将呈现 LOCK IN SHARE MODE 关于MySQL， FOR SHARE 在PostgreSQL上。在PostgreSQL上，当与 nowait 将渲染 FOR SHARE NOWAIT .

• of¶ -- SQL表达式或SQL表达式元素列表（通常 Column 对象或兼容表达式），它将呈现为 FOR UPDATE OF 子句；由PostgreSQL和Oracle支持。可以呈现为表或列，具体取决于后端。

• skip_locked¶ -- 布尔值，将呈现 FOR UPDATE SKIP LOCKED 关于Oracle和PostgreSQL方言或 FOR SHARE SKIP LOCKED 如果 read=True 也指定了。

• key_share¶ -- 布尔值，将呈现 FOR NO KEY UPDATE ，或者如果与 read=True 将渲染 FOR KEY SHARE 在PostgreSQL方言上。

class sqlalchemy.sql.expression.HasCTE¶

声明类以包含CTE支持的mixin。

1.1 新版功能.

类签名

class sqlalchemy.sql.expression.HasCTE (sqlalchemy.sql.roles.HasCTERole)

method sqlalchemy.sql.expression.HasCTE.add_cte(cte)¶

添加 CTE 添加到此语句对象，即使语句中未另外引用，该对象也将独立呈现。

对于将DML语句(如INSERT或UPDATE)作为CTE嵌入到可能间接从其结果中提取的主语句的用例中，此功能非常有用；虽然PostgreSQL已知支持这种用法，但其他后端可能不支持它。

例如。：：

from sqlalchemy import table, column, select
t = table('t', column('c1'), column('c2'))

ins = t.insert().values({"c1": "x", "c2": "y"}).cte()

stmt = select(t).add_cte(ins)

将呈现：：

WITH anon_1 AS
(INSERT INTO t (c1, c2) VALUES (:param_1, :param_2))
SELECT t.c1, t.c2
FROM t

上面，SELECT语句中没有引用“anon_1”CTE，但是它仍然完成了运行INSERT语句的任务。

同样，在与DML相关的上下文中，使用PostgreSQL Insert 构造以生成“upsert”：：

from sqlalchemy import table, column
from sqlalchemy.dialects.postgresql import insert

t = table("t", column("c1"), column("c2"))

delete_statement_cte = (
    t.delete().where(t.c.c1 < 1).cte("deletions")
)

insert_stmt = insert(t).values({"c1": 1, "c2": 2})
update_statement = insert_stmt.on_conflict_do_update(
    index_elements=[t.c.c1],
    set_={
        "c1": insert_stmt.excluded.c1,
        "c2": insert_stmt.excluded.c2,
    },
).add_cte(delete_statement_cte)

print(update_statement)

上面的语句呈现为：：

WITH deletions AS
(DELETE FROM t WHERE t.c1 < %(c1_1)s)
INSERT INTO t (c1, c2) VALUES (%(c1)s, %(c2)s)
ON CONFLICT (c1) DO UPDATE SET c1 = excluded.c1, c2 = excluded.c2

1.4.21 新版功能.

method sqlalchemy.sql.expression.HasCTE.cte(name=None, recursive=False, nesting=False)¶

返回一个新的 CTE 或公用表表达式实例。

公共表表达式是一种SQL标准，通过该标准，select语句可以使用名为“with”的子句，利用随主语句一起指定的辅助语句。还可以使用与union相关的特殊语义来允许“递归”查询，其中select语句可以根据以前选择的行集进行绘制。

CTE还可以应用于某些数据库上的DML构造更新、插入和删除，既可以作为与返回结合时CTE行的源，也可以作为CTE行的使用者。

在 1.1 版更改: 添加了对更新/插入/删除作为CTE的支持，将CTE添加到更新/插入/删除。

SQL炼金术检测 CTE 对象，其处理方式与 Alias 对象，作为要传递到语句的FROM子句以及语句顶部的WITH子句的特殊元素。

例如“非具体化的SQL”和“非具体化的SQL”前缀 CTE.prefix_with() 方法可以用来建立这些。

在 1.3.13 版更改: 增加了对前缀的支持。尤其是物化和非物化。

参数

• name¶ -- 为公用表表达式指定的名称。喜欢 FromClause.alias() ，名称可以保留为 None 在这种情况下，查询编译时将使用匿名符号。

• recursive¶ -- 如果 True 将渲染 WITH RECURSIVE . 递归公用表表达式将与union all一起使用，以便从已选定的行派生行。

• nesting¶ -- 如果 True ，将在本地将CTE呈现为实际语句。。。添加的版本：：1.4.24

下面的示例包括两个摘自PostgreSQL在https://www.postgresql.org/docs/current/static/queries-with.html，的文档以及其他示例。

示例1，非递归：

from sqlalchemy import (Table, Column, String, Integer,
                        MetaData, select, func)

metadata = MetaData()

orders = Table('orders', metadata,
    Column('region', String),
    Column('amount', Integer),
    Column('product', String),
    Column('quantity', Integer)
)

regional_sales = select(
                    orders.c.region,
                    func.sum(orders.c.amount).label('total_sales')
                ).group_by(orders.c.region).cte("regional_sales")


top_regions = select(regional_sales.c.region).\
        where(
            regional_sales.c.total_sales >
            select(
                func.sum(regional_sales.c.total_sales) / 10
            )
        ).cte("top_regions")

statement = select(
            orders.c.region,
            orders.c.product,
            func.sum(orders.c.quantity).label("product_units"),
            func.sum(orders.c.amount).label("product_sales")
    ).where(orders.c.region.in_(
        select(top_regions.c.region)
    )).group_by(orders.c.region, orders.c.product)

result = conn.execute(statement).fetchall()

示例2，递归：

from sqlalchemy import (Table, Column, String, Integer,
                        MetaData, select, func)

metadata = MetaData()

parts = Table('parts', metadata,
    Column('part', String),
    Column('sub_part', String),
    Column('quantity', Integer),
)

included_parts = select(\
    parts.c.sub_part, parts.c.part, parts.c.quantity\
    ).\
    where(parts.c.part=='our part').\
    cte(recursive=True)


incl_alias = included_parts.alias()
parts_alias = parts.alias()
included_parts = included_parts.union_all(
    select(
        parts_alias.c.sub_part,
        parts_alias.c.part,
        parts_alias.c.quantity
    ).\
    where(parts_alias.c.part==incl_alias.c.sub_part)
)

statement = select(
            included_parts.c.sub_part,
            func.sum(included_parts.c.quantity).
              label('total_quantity')
        ).\
        group_by(included_parts.c.sub_part)

result = conn.execute(statement).fetchall()

示例3，使用update和insert with ctes的upsert:：

from datetime import date
from sqlalchemy import (MetaData, Table, Column, Integer,
                        Date, select, literal, and_, exists)

metadata = MetaData()

visitors = Table('visitors', metadata,
    Column('product_id', Integer, primary_key=True),
    Column('date', Date, primary_key=True),
    Column('count', Integer),
)

# add 5 visitors for the product_id == 1
product_id = 1
day = date.today()
count = 5

update_cte = (
    visitors.update()
    .where(and_(visitors.c.product_id == product_id,
                visitors.c.date == day))
    .values(count=visitors.c.count + count)
    .returning(literal(1))
    .cte('update_cte')
)

upsert = visitors.insert().from_select(
    [visitors.c.product_id, visitors.c.date, visitors.c.count],
    select(literal(product_id), literal(day), literal(count))
        .where(~exists(update_cte.select()))
)

connection.execute(upsert)

示例4，嵌套CTE：：

value_a = select(
    literal("root").label("n")
).cte("value_a")

# A nested CTE with the same name as the root one
value_a_nested = select(
    literal("nesting").label("n")
).cte("value_a", nesting=True)

# Nesting CTEs takes ascendency locally
# over the CTEs at a higher level
value_b = select(value_a_nested.c.n).cte("value_b")

value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

上面的查询将呈现嵌套在第一个CTE中的第二个CTE，其内联参数如下所示：

WITH
    value_a AS
        (SELECT 'root' AS n),
    value_b AS
        (WITH value_a AS
            (SELECT 'nesting' AS n)
        SELECT value_a.n AS n FROM value_a)
SELECT value_a.n AS a, value_b.n AS b
FROM value_a, value_b

参见

Query.cte() -ORM版本 HasCTE.cte() .

class sqlalchemy.sql.expression.HasPrefixes¶

method sqlalchemy.sql.expression.HasPrefixes.prefix_with(*expr, **kw)¶

在语句关键字后添加一个或多个表达式，即select、insert、update或delete。生成的。

这用于支持后端特定的前缀关键字，如mysql提供的前缀关键字。

例如。：：

stmt = table.insert().prefix_with("LOW_PRIORITY", dialect="mysql")

# MySQL 5.7 optimizer hints
stmt = select(table).prefix_with(
    "/*+ BKA(t1) */", dialect="mysql")

可以通过多次调用指定多个前缀 HasPrefixes.prefix_with() .

参数

• *expr¶ -- 文本或 ClauseElement 在插入、更新或删除关键字后呈现的构造。

• **kw¶ -- 只接受一个关键字“dialect”。这是一个可选的字符串方言名称，它将此前缀的呈现限制为仅显示该方言。

class sqlalchemy.sql.expression.HasSuffixes¶

method sqlalchemy.sql.expression.HasSuffixes.suffix_with(*expr, **kw)¶

在语句后面整体添加一个或多个表达式。

这用于在某些构造上支持后端特定的后缀关键字。

例如。：：

stmt = select(col1, col2).cte().suffix_with(
    "cycle empno set y_cycle to 1 default 0", dialect="oracle")

可以通过多次调用指定多个后缀 HasSuffixes.suffix_with() .

参数

• *expr¶ -- 文本或 ClauseElement 在目标子句之后呈现的构造。

• **kw¶ -- 只接受一个关键字“dialect”。这是一个可选的字符串方言名称，它将此后缀的呈现限制为仅限于该方言。

class sqlalchemy.sql.expression.Join(left, right, onclause=None, isouter=False, full=False)¶

代表一个 JOIN 在两者之间构建 FromClause 元素。

的公共构造函数函数 Join 模块级别 join() 函数，以及 FromClause.join() 任意方法 FromClause （例如 Table ）

参见

join()

FromClause.join()

类签名

class sqlalchemy.sql.expression.Join (sqlalchemy.sql.roles.DMLTableRole, sqlalchemy.sql.expression.FromClause)

method sqlalchemy.sql.expression.Join.__init__(left, right, onclause=None, isouter=False, full=False)¶

构建新的 Join .

这里通常的入口点是 join() 函数或 FromClause.join() 任意方法 FromClause 对象。

method sqlalchemy.sql.expression.Join.alias(name=None, flat=False)¶

返回此的别名 Join .

1.4 版后已移除: 这个 Join.alias() 方法在SQLAlchemy的1.x系列中被认为是遗留的，并将在2.0中删除。而是创建一个select+子查询，或在联接中对各个表进行别名。（SQLAlchemy 2.0的背景： 迁移到Alchemy ）

这里的默认行为是首先从中生成一个select构造 Join ，然后生成 Alias 从那。所以给出了一个形式的连接：

j = table_a.join(table_b, table_a.c.id == table_b.c.a_id)

连接本身看起来像：

table_a JOIN table_b ON table_a.id = table_b.a_id

鉴于上述别名， j.alias() ，在选定的上下文中，将类似于：

(SELECT table_a.id AS table_a_id, table_b.id AS table_b_id,
    table_b.a_id AS table_b_a_id
    FROM table_a
    JOIN table_b ON table_a.id = table_b.a_id) AS anon_1

等效的长手形，给定 Join 对象 j 是：

from sqlalchemy import select, alias
j = alias(
    select(j.left, j.right).\
        select_from(j).\
        set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL).\
        correlate(False),
    name=name
)

生产的可选 Join.alias() 与在单个名称下显示的两个单独的可选项具有相同的列-单独的列是“自动标记的”，这意味着 .c. 结果的集合 Alias 表示使用 <tablename>_<columname> 方案：

j.c.table_a_id
j.c.table_b_a_id

Join.alias() 另外还有一个别名连接的替代选项，它不产生封闭的选择，并且通常不向列名称应用标签。这个 flat=True 选项将调用 FromClause.alias() 分别靠在左右两侧。使用此选项，没有新的 SELECT 是由以下结构产生的：

j = table_a.join(table_b, table_a.c.id == table_b.c.a_id)
j = j.alias(flat=True)

我们得到这样的结果：

table_a AS table_a_1 JOIN table_b AS table_b_1 ON
table_a_1.id = table_b_1.a_id

这个 flat=True 参数也会传播到包含的可选择项，以便复合联接，如：：

j = table_a.join(
        table_b.join(table_c,
                table_b.c.id == table_c.c.b_id),
        table_b.c.a_id == table_a.c.id
    ).alias(flat=True)

将生成如下表达式：

table_a AS table_a_1 JOIN (
        table_b AS table_b_1 JOIN table_c AS table_c_1
        ON table_b_1.id = table_c_1.b_id
) ON table_a_1.id = table_b_1.a_id

独立的 alias() 功能和基础 FromClause.alias() 方法还支持 flat=True 参数作为no op，以便可以将该参数传递给 alias() 任何可选方法。

参数

• name¶ -- 给别名的名称。

• flat¶ -- 如果为真，则生成此的左右两侧的别名 Join 并返回这两个可选择项的联接。这将生成不包含封闭选择的联接表达式。

参见

使用别名和子查询

alias()

attribute sqlalchemy.sql.expression.Join.bind¶

返回与此左侧或右侧关联的绑定引擎 Join .

1.4 版后已移除: 这个 Executable.bind 属性在SQLAlchemy的1.x系列中被认为是遗留的，将在2.0中删除。从SQLAlchemy 2.0开始，绑定的元数据将被删除。（SQLAlchemy 2.0的背景： 迁移到Alchemy ）

attribute sqlalchemy.sql.expression.Join.description¶

method sqlalchemy.sql.expression.Join.is_derived_from(fromclause)¶

返回 True 如果这样 FromClause 是从给定的 FromClause .

例如，表的别名是从该表派生的。

method sqlalchemy.sql.expression.Join.select(whereclause=None, **kwargs)¶

创建一个 Select 由此 Join .

例如。：：

stmt = table_a.join(table_b, table_a.c.id == table_b.c.a_id)

stmt = stmt.select()

上面将生成一个类似于的SQL字符串：

SELECT table_a.id, table_a.col, table_b.id, table_b.a_id
FROM table_a JOIN table_b ON table_a.id = table_b.a_id

参数

• whereclause¶ -- WHERE条件，与调用相同 Select.where() 在结果语句上。。已弃用：：1.4 Join.select().whereclause 参数已弃用，将在版本2.0中删除。请利用 Select.where() 方法将WHERE条件添加到SELECT语句。

• **kwargs¶ -- 其他关键字参数传递给的旧构造函数 Select 描述在 Select.create_legacy_select() .

method sqlalchemy.sql.expression.Join.self_group(against=None)¶

对此应用“分组” ClauseElement .

此方法被子类重写以返回“grouping”构造，即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组，以及 select() 当放入另一个的FROM子句时构造 select() . （请注意，通常应使用 Select.alias() 方法，因为许多平台都需要命名嵌套的select语句）。

当表达式组合在一起时，应用 self_group() 是自动的-最终用户代码不需要直接使用这个方法。请注意，sqlachemy的子句构造将运算符优先考虑在内，因此可能不需要括号，例如，在类似这样的表达式中 x OR (y AND z) -优先于或。

底座 self_group() 方法 ClauseElement 只需返回自我。

class sqlalchemy.sql.expression.Lateral(*arg, **kw)¶

表示横向子查询。

此对象是由 lateral() 模块级功能以及 FromClause.lateral() 方法适用于所有 FromClause 子类。

虽然横向是SQL标准的一部分，但目前只有更新的PostgreSQL版本才支持这个关键字。

1.1 新版功能.

参见

横向相关 -使用概述。

类签名

class sqlalchemy.sql.expression.Lateral (sqlalchemy.sql.expression.AliasedReturnsRows)

class sqlalchemy.sql.expression.ReturnsRows¶

Core构造的最基本类，它具有一些可以表示行的列概念。

虽然SELECT语句和表是我们在这个类别中考虑的主要内容，但是像INSERT、UPDATE和DELETE这样的DML也可以指定return，这意味着它们可以在cte和其他表单中使用，PostgreSQL还具有返回行的函数。

1.4 新版功能.

类签名

class sqlalchemy.sql.expression.ReturnsRows (sqlalchemy.sql.roles.ReturnsRowsRole, sqlalchemy.sql.expression.ClauseElement)

attribute sqlalchemy.sql.expression.ReturnsRows.exported_columns¶

A ColumnCollection 它表示此的“导出”列 ReturnsRows .

“导出”列表示 ColumnElement 此SQL构造呈现的表达式。有一些主要变体是FROM子句的“FROM子句列”，例如表、联接或子查询，“SELECTed columns”是SELECT语句的“columns子句”中的列，以及DML语句中的返回列。。

1.4 新版功能.

参见

FromClause.exported_columns

SelectBase.exported_columns

class sqlalchemy.sql.expression.ScalarSelect(element)¶

表示标量子查询。

A ScalarSelect 通过调用 SelectBase.scalar_subquery() 方法。然后，该对象以SQL列表达式的形式参与其他SQL表达式 ColumnElement 层次结构。

参见

SelectBase.scalar_subquery()

标量和相关子查询 -在2.0教程中

标量选择 -在1.x教程中

类签名

class sqlalchemy.sql.expression.ScalarSelect (sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.Grouping)

method sqlalchemy.sql.expression.ScalarSelect.correlate(*fromclauses)¶

返回一个新的 ScalarSelect 它将给定的FROM子句与包含的子句相关联 Select .

此方法从 Select.correlate() 底层的方法 Select . 该方法应用 :meth:_sql.Select.correlate` method, then returns a new ScalarSelect 反对这种说法。

1.4 新版功能: 以前， ScalarSelect.correlate() 方法只能从 Select .

参数

*fromclauses¶ -- 一个或多个列表 FromClause 构造或其他兼容的构造（即ORM映射类）将成为相关集合的一部分。

参见

ScalarSelect.correlate_except()

标量和相关子查询 -在2.0教程中

关联子查询 -在1.x教程中

method sqlalchemy.sql.expression.ScalarSelect.correlate_except(*fromclauses)¶

返回一个新的 ScalarSelect 它将从自相关过程中省略给定的FROM子句。

此方法从 Select.correlate_except() 底层的方法 Select . 该方法应用 :meth:_sql.Select.correlate_except` method, then returns a new ScalarSelect 反对这种说法。

1.4 新版功能: 以前， ScalarSelect.correlate_except() 方法只能从 Select .

参数

*fromclauses¶ -- 一个或多个列表 FromClause 构造或其他兼容的构造（即ORM映射类）将成为相关异常集合的一部分。

参见

ScalarSelect.correlate()

标量和相关子查询 -在2.0教程中

关联子查询 -在1.x教程中

method sqlalchemy.sql.expression.ScalarSelect.self_group(**kwargs)¶

对此应用“分组” ClauseElement .

此方法被子类重写以返回“grouping”构造，即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组，以及 select() 当放入另一个的FROM子句时构造 select() . （请注意，通常应使用 Select.alias() 方法，因为许多平台都需要命名嵌套的select语句）。

当表达式组合在一起时，应用 self_group() 是自动的-最终用户代码不需要直接使用这个方法。请注意，sqlachemy的子句构造将运算符优先考虑在内，因此可能不需要括号，例如，在类似这样的表达式中 x OR (y AND z) -优先于或。

底座 self_group() 方法 ClauseElement 只需返回自我。

method sqlalchemy.sql.expression.ScalarSelect.where(crit)¶

将WHERE子句应用于此引用的SELECT语句 ScalarSelect .

class sqlalchemy.sql.expression.Select¶

表示 SELECT 语句。

这个 Select 对象通常使用 select() 功能。有关详细信息，请参见该函数。

参见

select()

选择 -在1.x教程中

使用核心或ORM选择行 -在2.0教程中

类签名

class sqlalchemy.sql.expression.Select (sqlalchemy.sql.expression.HasPrefixes, sqlalchemy.sql.expression.HasSuffixes, sqlalchemy.sql.expression.HasHints, sqlalchemy.sql.expression.HasCompileState, sqlalchemy.sql.expression.DeprecatedSelectGenerations, sqlalchemy.sql.expression._SelectFromElements, sqlalchemy.sql.expression.GenerativeSelect)

method sqlalchemy.sql.expression.Select.add_columns(*columns)¶

返回一个新的 select() 将给定的列表达式添加到其columns子句中。

例如。：：

my_select = my_select.add_columns(table.c.new_column)

参见文档 Select.with_only_columns() 有关添加/替换 Select 对象。

method sqlalchemy.sql.expression.Select.add_cte(cte)¶

inherited from the HasCTE.add_cte() method of HasCTE

添加 CTE 添加到此语句对象，即使语句中未另外引用，该对象也将独立呈现。

对于将DML语句(如INSERT或UPDATE)作为CTE嵌入到可能间接从其结果中提取的主语句的用例中，此功能非常有用；虽然PostgreSQL已知支持这种用法，但其他后端可能不支持它。

例如。：：

from sqlalchemy import table, column, select
t = table('t', column('c1'), column('c2'))

ins = t.insert().values({"c1": "x", "c2": "y"}).cte()

stmt = select(t).add_cte(ins)

将呈现：：

WITH anon_1 AS
(INSERT INTO t (c1, c2) VALUES (:param_1, :param_2))
SELECT t.c1, t.c2
FROM t

上面，SELECT语句中没有引用“anon_1”CTE，但是它仍然完成了运行INSERT语句的任务。

同样，在与DML相关的上下文中，使用PostgreSQL Insert 构造以生成“upsert”：：

from sqlalchemy import table, column
from sqlalchemy.dialects.postgresql import insert

t = table("t", column("c1"), column("c2"))

delete_statement_cte = (
    t.delete().where(t.c.c1 < 1).cte("deletions")
)

insert_stmt = insert(t).values({"c1": 1, "c2": 2})
update_statement = insert_stmt.on_conflict_do_update(
    index_elements=[t.c.c1],
    set_={
        "c1": insert_stmt.excluded.c1,
        "c2": insert_stmt.excluded.c2,
    },
).add_cte(delete_statement_cte)

print(update_statement)

上面的语句呈现为：：

WITH deletions AS
(DELETE FROM t WHERE t.c1 < %(c1_1)s)
INSERT INTO t (c1, c2) VALUES (%(c1)s, %(c2)s)
ON CONFLICT (c1) DO UPDATE SET c1 = excluded.c1, c2 = excluded.c2

1.4.21 新版功能.

method sqlalchemy.sql.expression.Select.alias(name=None, flat=False)¶

inherited from the SelectBase.alias() method of SelectBase

针对此返回命名子查询 SelectBase .

对于一个 SelectBase （与 FromClause ，这将返回 Subquery 对象的行为与 Alias 与一起使用的对象 FromClause .

在 1.4 版更改: 这个 SelectBase.alias() 方法现在是 SelectBase.subquery() 方法。

method sqlalchemy.sql.expression.Select.apply_labels()¶

inherited from the GenerativeSelect.apply_labels() method of GenerativeSelect

1.4 版后已移除: 这个 GenerativeSelect.apply_labels() 方法被认为是SQLAlChemy 1.x系列的遗留方法，将在2.0中删除。请改用set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL)。(有关SQLAlChemy 2.0的背景信息位于： 迁移到Alchemy )

method sqlalchemy.sql.expression.Select.as_scalar()¶

inherited from the SelectBase.as_scalar() method of SelectBase

1.4 版后已移除: 这个 SelectBase.as_scalar() 方法已弃用，将在将来的版本中删除。请参考 SelectBase.scalar_subquery() .

attribute sqlalchemy.sql.expression.Select.bind¶

返回 Engine 或 Connection 对此 Executable 是绑定的，如果未找到，则为无。

1.4 版后已移除: 这个 Executable.bind 属性在SQLAlchemy的1.x系列中被认为是遗留的，将在2.0中删除。从SQLAlchemy 2.0开始，绑定的元数据将被删除。（SQLAlchemy 2.0的背景： 迁移到Alchemy ）

attribute sqlalchemy.sql.expression.Select.c¶

inherited from the SelectBase.c attribute of SelectBase

1.4 版后已移除: 这个 SelectBase.c 和 SelectBase.columns 属性已弃用，将在将来的版本中删除；这些属性隐式创建一个应显式的子查询。请给我打电话 SelectBase.subquery() 首先创建一个子查询，然后包含该属性。要访问此选择对象所选的列，请使用 SelectBase.selected_columns 属性。

method sqlalchemy.sql.expression.Select.column(column)¶

返回一个新的 select() 构造，并将给定的列表达式添加到其columns子句中。

1.4 版后已移除: 这个 Select.column() 方法已弃用，将在将来的版本中删除。请使用 Select.add_columns()

例如。：：

my_select = my_select.column(table.c.new_column)

参见文档 Select.with_only_columns() 有关添加/替换 Select 对象。

attribute sqlalchemy.sql.expression.Select.column_descriptions¶

返回“column descriptions”结构，该结构可以是 plugin-specific .

attribute sqlalchemy.sql.expression.Select.columns_clause_froms¶

返回一组 FromClause 此SELECT语句的COLUMNS子句隐含的对象。

1.4.23 新版功能.

参见

Select.froms -考虑到完整声明的列表中的“最终”

Select.with_only_columns() -利用此集合设置新的发件人列表

method sqlalchemy.sql.expression.Select.correlate(*fromclauses)¶

返回一个新的 Select 它将给定的FROM子句与包含的子句相关联 Select .

调用此方法将关闭 Select 对象的默认“自动相关”行为。通常，从出现在 Select 它通过 WHERE clause ，订购人，拥有或 columns clause 将从中删除 Select 对象的 FROM clause . 使用设置显式相关集合 Select.correlate() 方法提供可能在此过程中发生的来自对象的固定列表。

什么时候？ Select.correlate() 用于将特定的From子句应用于相关性，而From元素将成为相关性的候选者，而不管它嵌套的深度如何 Select 对象相对于封闭对象 Select 从对象引用相同的。这与“自动关联”的行为形成了对比，后者只与即时封闭相关联。 Select . 多级关联保证了封闭与封闭之间的联系 Select 总是通过至少一个WHERE/ORDER BY/HAVING/COLUMNS子句进行关联。

如果 None 通过， Select 对象将不关联其任何FROM条目，并且所有条目都将在本地FROM子句中无条件呈现。

参数

*fromclauses¶ -- 一个或多个列表 FromClause 构造或其他兼容的构造（即ORM映射类）将成为相关集合的一部分。

参见

Select.correlate_except()

关联子查询

method sqlalchemy.sql.expression.Select.correlate_except(*fromclauses)¶

返回一个新的 Select 它将从自相关过程中省略给定的FROM子句。

调用 Select.correlate_except() 关掉 Select 对象对于给定的源元素的“自动相关”默认行为。此处指定的元素将无条件地显示在“发件人”列表中，而所有其他“发件人”元素都将服从正常的自动相关行为。

如果 None 通过， Select 对象将关联其所有源项。

参数

*fromclauses¶ -- 一个或多个列表 FromClause 构造或其他兼容的构造（即ORM映射类）将成为相关异常集合的一部分。

参见

Select.correlate()

关联子查询

method sqlalchemy.sql.expression.Select.corresponding_column(column, require_embedded=False)¶

inherited from the Selectable.corresponding_column() method of Selectable

给出了一个 ColumnElement ，返回导出的 ColumnElement 对象从 Selectable.exported_columns 这个的集合 Selectable 与原件相对应 ColumnElement 通过一个共同的祖先列。

参数

• column¶ -- 目标 ColumnElement 相配。

• require_embedded¶ -- 仅返回给定的对应列 ColumnElement ，如果给定的 ColumnElement 实际存在于此子元素中 Selectable . 通常情况下，如果该列仅与该列的导出列共享一个共同的祖先，则该列将匹配 Selectable .

参见

Selectable.exported_columns - ColumnCollection 那是用来做手术的。

ColumnCollection.corresponding_column() -实施方法。

method sqlalchemy.sql.expression.Select.classmethod create_legacy_select(columns=None, whereclause=None, from_obj=None, distinct=False, having=None, correlate=True, prefixes=None, suffixes=None, **kwargs)¶

构建新的 Select 使用1.x样式的API。

1.4 版后已移除: 传统的调用方式 select() 已弃用，将在SQLAlchemy 2.0中删除。请使用中描述的新呼叫方式 select() . （SQLAlchemy 2.0的背景： 迁移到Alchemy ）

当 select() construct，第一个参数是Python列表或其他纯序列对象，用于引用columns集合。

在 1.4 版更改: 增加了 Select.create_legacy_select() 构造函数，它记录在 select() 构造是使用1.x样式的参数调用的。

类似功能也可通过 FromClause.select() 任意方法 FromClause .

接受的所有参数 ClauseElement 参数还接受字符串参数，这些参数将根据需要转换为 text() 或 literal_column() 构造。

参见

选择 -核心教程说明 select() .

参数

• columns¶ --

  列表 ColumnElement 或 FromClause 将构成结果语句的columns子句的对象。对于那些属于 FromClause （典型地 Table 或 Alias 对象） FromClause.c 提取集合以形成 ColumnElement 物体。

  此参数也将接受 TextClause 构造，以及ORM映射类。

  注解

  这个 select.columns 参数的方法形式不可用 select() ，例如 FromClause.select() .

  参见

  Select.column()

  Select.with_only_columns()

• whereclause¶ -- A ClauseElement 将用于构成 WHERE 条款。通常，最好将Where条件添加到现有的 Select 使用方法链接 Select.where() . …参阅： Select.where()

• from_obj¶ -- 列表 ClauseElement 将添加到 FROM 结果语句的子句。这相当于呼叫 Select.select_from() 在现有的 Select 对象。…参阅： Select.select_from() -明确的从句规范的完整描述。

• bind=None¶ -- 一个 Engine 或 Connection 结果所指向的实例 Select 对象将被绑定。这个 Select 否则，对象将自动绑定到 Connectable 实例可以位于其包含的 ClauseElement 成员。

• correlate=True¶ -- 表示此 Select 对象应该包含它 FromClause 元素“相关”到封闭 Select 对象。通常，最好在现有的 Select 构建使用 Select.correlate() . …参阅： Select.correlate() -相关性的完整描述。

• distinct=False¶ -- 什么时候？ True 应用A DISTINCT 结果语句的columns子句的限定符。布尔参数也可以是列表达式或列表达式列表-这是一种特殊的调用形式，PostgreSQL方言可以理解它来呈现 DISTINCT ON (<columns>) 语法。 distinct 也可以在现有的 Select 对象通过 Select.distinct() 方法。…参阅： Select.distinct()

• group_by¶ -- 一览表 ClauseElement 将构成 GROUP BY 结果选择的子句。通常使用 Select.group_by() 现有的方法 Select . …参阅： Select.group_by()

• having¶ -- 一 ClauseElement 这将包括 HAVING 结果select when的子句 GROUP BY 使用。通常使用 Select.having() 现有的方法 Select . …参阅： Select.having()

• limit=None¶ -- 通常呈现为 LIMIT 结果选择中的表达式。不支持的后端 LIMIT 将尝试提供类似的功能。通常使用 Select.limit() 现有的方法 Select . …参阅： Select.limit()

• offset=None¶ -- 通常呈现为 OFFSET 结果选择中的表达式。不支持的后端 OFFSET 将尝试提供类似的功能。通常使用 Select.offset() 现有的方法 Select . …参阅： Select.offset()

• order_by¶ -- 标量或列表 ClauseElement 将构成 ORDER BY 结果选择的子句。通常使用 Select.order_by() 现有的方法 Select . …参阅： Select.order_by()

• use_labels=False¶ -- 什么时候 True 时，将使用COLUMNS子句中每列的标签生成语句，这将用其父表(或别名)名称限定每列，以便不同表中的列之间不会发生名称冲突。标签的格式为 <tablename>_<column> 。对象的“c”集合 Subquery 针对此创建 Select 对象，以及 Select.selected_columns 集合中的 Select 本身将使用这些名称作为列成员的目标。也可以在现有的 Select 对象使用 Select.set_label_style() 方法。。。另请参阅：： Select.set_label_style()

method sqlalchemy.sql.expression.Select.cte(name=None, recursive=False, nesting=False)¶

inherited from the HasCTE.cte() method of HasCTE

返回一个新的 CTE 或公用表表达式实例。

公共表表达式是一种SQL标准，通过该标准，select语句可以使用名为“with”的子句，利用随主语句一起指定的辅助语句。还可以使用与union相关的特殊语义来允许“递归”查询，其中select语句可以根据以前选择的行集进行绘制。

CTE还可以应用于某些数据库上的DML构造更新、插入和删除，既可以作为与返回结合时CTE行的源，也可以作为CTE行的使用者。

在 1.1 版更改: 添加了对更新/插入/删除作为CTE的支持，将CTE添加到更新/插入/删除。

SQL炼金术检测 CTE 对象，其处理方式与 Alias 对象，作为要传递到语句的FROM子句以及语句顶部的WITH子句的特殊元素。

例如“非具体化的SQL”和“非具体化的SQL”前缀 CTE.prefix_with() 方法可以用来建立这些。

在 1.3.13 版更改: 增加了对前缀的支持。尤其是物化和非物化。

参数

• name¶ -- 为公用表表达式指定的名称。喜欢 FromClause.alias() ，名称可以保留为 None 在这种情况下，查询编译时将使用匿名符号。

• recursive¶ -- 如果 True 将渲染 WITH RECURSIVE . 递归公用表表达式将与union all一起使用，以便从已选定的行派生行。

• nesting¶ -- 如果 True ，将在本地将CTE呈现为实际语句。。。添加的版本：：1.4.24

下面的示例包括两个摘自PostgreSQL在https://www.postgresql.org/docs/current/static/queries-with.html，的文档以及其他示例。

示例1，非递归：

from sqlalchemy import (Table, Column, String, Integer,
                        MetaData, select, func)

metadata = MetaData()

orders = Table('orders', metadata,
    Column('region', String),
    Column('amount', Integer),
    Column('product', String),
    Column('quantity', Integer)
)

regional_sales = select(
                    orders.c.region,
                    func.sum(orders.c.amount).label('total_sales')
                ).group_by(orders.c.region).cte("regional_sales")


top_regions = select(regional_sales.c.region).\
        where(
            regional_sales.c.total_sales >
            select(
                func.sum(regional_sales.c.total_sales) / 10
            )
        ).cte("top_regions")

statement = select(
            orders.c.region,
            orders.c.product,
            func.sum(orders.c.quantity).label("product_units"),
            func.sum(orders.c.amount).label("product_sales")
    ).where(orders.c.region.in_(
        select(top_regions.c.region)
    )).group_by(orders.c.region, orders.c.product)

result = conn.execute(statement).fetchall()

示例2，递归：

from sqlalchemy import (Table, Column, String, Integer,
                        MetaData, select, func)

metadata = MetaData()

parts = Table('parts', metadata,
    Column('part', String),
    Column('sub_part', String),
    Column('quantity', Integer),
)

included_parts = select(\
    parts.c.sub_part, parts.c.part, parts.c.quantity\
    ).\
    where(parts.c.part=='our part').\
    cte(recursive=True)


incl_alias = included_parts.alias()
parts_alias = parts.alias()
included_parts = included_parts.union_all(
    select(
        parts_alias.c.sub_part,
        parts_alias.c.part,
        parts_alias.c.quantity
    ).\
    where(parts_alias.c.part==incl_alias.c.sub_part)
)

statement = select(
            included_parts.c.sub_part,
            func.sum(included_parts.c.quantity).
              label('total_quantity')
        ).\
        group_by(included_parts.c.sub_part)

result = conn.execute(statement).fetchall()

示例3，使用update和insert with ctes的upsert:：

from datetime import date
from sqlalchemy import (MetaData, Table, Column, Integer,
                        Date, select, literal, and_, exists)

metadata = MetaData()

visitors = Table('visitors', metadata,
    Column('product_id', Integer, primary_key=True),
    Column('date', Date, primary_key=True),
    Column('count', Integer),
)

# add 5 visitors for the product_id == 1
product_id = 1
day = date.today()
count = 5

update_cte = (
    visitors.update()
    .where(and_(visitors.c.product_id == product_id,
                visitors.c.date == day))
    .values(count=visitors.c.count + count)
    .returning(literal(1))
    .cte('update_cte')
)

upsert = visitors.insert().from_select(
    [visitors.c.product_id, visitors.c.date, visitors.c.count],
    select(literal(product_id), literal(day), literal(count))
        .where(~exists(update_cte.select()))
)

connection.execute(upsert)

示例4，嵌套CTE：：

value_a = select(
    literal("root").label("n")
).cte("value_a")

# A nested CTE with the same name as the root one
value_a_nested = select(
    literal("nesting").label("n")
).cte("value_a", nesting=True)

# Nesting CTEs takes ascendency locally
# over the CTEs at a higher level
value_b = select(value_a_nested.c.n).cte("value_b")

value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

上面的查询将呈现嵌套在第一个CTE中的第二个CTE，其内联参数如下所示：

WITH
    value_a AS
        (SELECT 'root' AS n),
    value_b AS
        (WITH value_a AS
            (SELECT 'nesting' AS n)
        SELECT value_a.n AS n FROM value_a)
SELECT value_a.n AS a, value_b.n AS b
FROM value_a, value_b

参见

Query.cte() -ORM版本 HasCTE.cte() .

method sqlalchemy.sql.expression.Select.distinct(*expr)¶

返回一个新的 select() 构造，它将对其columns子句应用DISTINCT。

参数

*expr¶ -- 可选列表达式。当存在时，PostgreSQL方言将呈现 DISTINCT ON (<expressions>>) 构造。。已弃用：：1.4使用 * 其他方言中的expr已被弃用，并将提高 CompileError 在未来的版本中。

method sqlalchemy.sql.expression.Select.except_(other, **kwargs)¶

返回SQL EXCEPT 此select（）构造的。

method sqlalchemy.sql.expression.Select.except_all(other, **kwargs)¶

返回SQL EXCEPT ALL 此select（）构造的。

method sqlalchemy.sql.expression.Select.execute(*multiparams, **params)¶

inherited from the Executable.execute() method of Executable

编译并执行此 Executable .

1.4 版后已移除: 这个 Executable.execute() 方法在SQLAlchemy的1.x系列中被认为是遗留的，并将在2.0中删除。SQLAlchemy 2.0中的所有语句执行都由 Connection.execute() 方法 Connection ，或在ORM中 Session.execute() 方法 Session . （SQLAlchemy 2.0的背景： 迁移到Alchemy ）

method sqlalchemy.sql.expression.Select.execution_options(**kw)¶

inherited from the Executable.execution_options() method of Executable

为在执行期间生效的语句设置非SQL选项。

可以对每个语句或每个语句设置执行选项。 Connection 基础。另外， Engine 和ORM Query 对象提供对执行选项的访问，这些执行选项反过来在连接时进行配置。

这个 execution_options() 方法是生成的。返回此语句的新实例，其中包含以下选项：

statement = select(table.c.x, table.c.y)
statement = statement.execution_options(autocommit=True)

请注意，只有可能的执行选项的一个子集可以应用于语句-这些选项包括“autocommit”和“stream_results”，但不包括“isolation_level”或“compiled_cache”。见 Connection.execution_options() 完整的选项列表。

参见

Connection.execution_options()

Query.execution_options()

Executable.get_execution_options()

method sqlalchemy.sql.expression.Select.exists()¶

inherited from the SelectBase.exists() method of SelectBase

返回一 Exists 可选择列作为此表达式的表示形式。

返回的对象是 Exists .

参见

exists()

存在的子查询 -在 2.0 style 辅导的。

1.4 新版功能.

attribute sqlalchemy.sql.expression.Select.exported_columns¶

inherited from the SelectBase.exported_columns attribute of SelectBase

A ColumnCollection 的“导出”列的 Selectable ，不包括 TextClause 构造。

的“导出”列 SelectBase 对象与 SelectBase.selected_columns 收集。

1.4 新版功能.

参见

Select.exported_columns

Selectable.exported_columns

FromClause.exported_columns

method sqlalchemy.sql.expression.Select.fetch(count, with_ties=False, percent=False)¶

inherited from the GenerativeSelect.fetch() method of GenerativeSelect

返回一个新的可选择的，并应用给定的先取条件。

这是一个数值，通常呈现为 FETCH {{FIRST | NEXT}} [ count ] {{ROW | ROWS}} {{ONLY | WITH TIES}} 结果select中的表达式。此功能目前在Oracle、PostgreSQL、MSSQL中实现。

使用 GenerativeSelect.offset() 指定偏移。

注解

这个 GenerativeSelect.fetch() 方法将替换应用的任何子句 GenerativeSelect.limit() .

1.4 新版功能.

参数

• count¶ -- 整数计数参数，或提供整数结果的SQL表达式。什么时候？ percent=True 这将表示要返回的行的百分比，而不是绝对值。通过 None 重置它。

• with_ties¶ -- 什么时候？ True ，WITH TIES选项用于根据 ORDER BY 条款。这个 ORDER BY 在这种情况下可能是强制性的。默认为 False

• percent¶ -- 什么时候？ True ， count 表示要返回的选定行总数的百分比。默认为 False

参见

GenerativeSelect.limit()

GenerativeSelect.offset()

method sqlalchemy.sql.expression.Select.filter(*criteria)¶

的同义词 Select.where() 方法。

method sqlalchemy.sql.expression.Select.filter_by(**kwargs)¶

将给定的筛选条件作为WHERE子句应用于此select。

method sqlalchemy.sql.expression.Select.from_statement(statement)¶

应用此列 Select 会选择另一个语句。

这次行动是 plugin-specific 并将引发不支持的异常，如果 Select 不从启用插件的实体中选择。

语句通常是 text() 或 select() 构造，并应返回与此表示的实体相应的列集 Select .

参见

从文本和核心语句获取ORM结果 -ORM查询指南中的用法示例

attribute sqlalchemy.sql.expression.Select.froms¶

返回显示的列表 FromClause 元素。

1.4.23 版后已移除: 这个 Select.froms 属性被移动到 Select.get_final_froms() 方法。

method sqlalchemy.sql.expression.Select.get_children(**kwargs)¶

返回直接子项 Traversible 其中的要素 Traversible .

用于访问遍历。

* *kw可能包含更改返回的集合的标志，例如返回一个子集以减少较大的遍历，或者从不同的上下文返回子项（例如模式级集合而不是子句级集合）。

method sqlalchemy.sql.expression.Select.get_execution_options()¶

inherited from the Executable.get_execution_options() method of Executable

获取将在执行期间生效的非SQL选项。

1.3 新版功能.

参见

Executable.execution_options()

method sqlalchemy.sql.expression.Select.get_final_froms()¶

计算最终显示的列表 FromClause 元素。

此方法将运行确定结果SELECT语句中将显示哪些FROM元素所需的全部计算，包括使用联接对象跟踪单个表，以及对ORM用例(包括急切加载子句)进行全部计算。

对于ORM使用，此访问器返回 后期编译 From对象的列表；此集合将包括急切加载的表和联接等元素。这些对象将 not 启用ORM，并且不能替代 Select.select_froms() 集合；此外，对于启用了ORM的语句，该方法的性能不佳，因为它将导致整个ORM构造过程。

检索传递给 Select 最初，使用 Select.columns_clause_froms 访问者。

若要在维护“发件人”列表的同时从另一组列中进行选择，请使用 Select.with_only_columns() 方法，并将 Select.with_only_columns.maintain_column_froms 参数。

1.4.23 新版功能: -The Select.get_final_froms() 方法替换以前的 Select.froms 访问器，它已弃用。

参见

Select.columns_clause_froms

method sqlalchemy.sql.expression.Select.get_label_style()¶

inherited from the GenerativeSelect.get_label_style() method of GenerativeSelect

检索当前标签样式。

1.4 新版功能.

method sqlalchemy.sql.expression.Select.group_by(*clauses)¶

inherited from the GenerativeSelect.group_by() method of GenerativeSelect

返回一个新的可选列表，并应用分组依据条件的给定列表。

例如。：：

stmt = select(table.c.name, func.max(table.c.stat)).\
group_by(table.c.name)

参数

*clauses¶ -- 一系列 ColumnElement 用于生成group by子句的构造。

参见

使用GROUP BY/HAVING聚合函数 - in the SQLAlchemy 1.4/2.0教程

按标签排序或分组 - in the SQLAlchemy 1.4/2.0教程

method sqlalchemy.sql.expression.Select.having(having)¶

返回一个新的 select() 将给定表达式添加到其HAVING子句中，并通过AND（如果有）连接到现有子句。

attribute sqlalchemy.sql.expression.Select.inner_columns¶

所有的迭代器 ColumnElement 将呈现到结果SELECT语句的columns子句中的表达式。

此方法是1.4版的遗留方法，并被 Select.exported_columns 收集。

method sqlalchemy.sql.expression.Select.intersect(other, **kwargs)¶

返回SQL INTERSECT 此select（）构造的。

method sqlalchemy.sql.expression.Select.intersect_all(other, **kwargs)¶

返回SQL INTERSECT ALL 此select（）构造的。

method sqlalchemy.sql.expression.Select.join(target, onclause=None, isouter=False, full=False)¶

针对此创建SQL联接 Select 对象的标准并生成应用，返回新生成的 Select .

例如。：：

stmt = select(user_table).join(address_table, user_table.c.id == address_table.c.user_id)

以上语句生成的SQL类似于：：

SELECT user.id, user.name FROM user JOIN address ON user.id = address.user_id

在 1.4 版更改: Select.join() 现在创建一个 Join 对象之间 FromClause 位于现有SELECT的FROM子句中的源，以及给定的目标 FromClause ，然后添加这个 Join 新生成的SELECT语句的FROM子句。这完全是对1.3中的行为进行了修改，它将创建整个 Select 然后将该子查询连接到目标。

这是一个 向后不兼容更改 由于前面的行为基本上是无用的，因此产生了一个未命名的子查询，这在任何情况下都会被大多数数据库拒绝。新的行为是模仿那些非常成功的 Query.join() 方法，以支持 Query 通过使用 Select 对象与 Session .

有关此更改的说明，请参见 select（）.join（）和outerjoin（）将连接条件添加到当前查询，而不是创建子查询 .

参数

• target¶ -- 要加入的目标表

• onclause¶ -- 连接的ON子句。如果省略，则根据 ForeignKey 如果可以明确确定两个表之间的链接，则会引发错误。

• isouter¶ -- 如果为True，则生成外部联接。等同于 Select.outerjoin() .

• full¶ -- 如果为True，则生成完整的外部联接。

参见

显式FROM子句和连接 - in the SQLAlchemy 1.4/2.0教程

联接 - in the ORM查询指南

Select.join_from()

Select.outerjoin()

method sqlalchemy.sql.expression.Select.join_from(from_, target, onclause=None, isouter=False, full=False)¶

针对此创建SQL联接 Select 对象的标准并生成应用，返回新生成的 Select .

例如。：：

stmt = select(user_table, address_table).join_from(
    user_table, address_table, user_table.c.id == address_table.c.user_id
)

以上语句生成的SQL类似于：：

SELECT user.id, user.name, address.id, address.email, address.user_id
FROM user JOIN address ON user.id = address.user_id

1.4 新版功能.

参数

• from_¶ -- 连接的左侧将在FROM子句中呈现，大致相当于使用 Select.select_from() 方法。

• target¶ -- 要加入的目标表

• onclause¶ -- 连接的ON子句。

• isouter¶ -- 如果为True，则生成外部联接。等同于 Select.outerjoin() .

• full¶ -- 如果为True，则生成完整的外部联接。

参见

显式FROM子句和连接 - in the SQLAlchemy 1.4/2.0教程

联接 - in the ORM查询指南

Select.join()

method sqlalchemy.sql.expression.Select.label(name)¶

inherited from the SelectBase.label() method of SelectBase

返回此可选的“标量”表示形式，嵌入为带有标签的子查询。

参见

SelectBase.as_scalar() .

method sqlalchemy.sql.expression.Select.lateral(name=None)¶

inherited from the SelectBase.lateral() method of SelectBase

返回此的横向别名 Selectable .

返回值是 Lateral 顶层也提供施工 lateral() 功能。

1.1 新版功能.

参见

横向相关 -使用概述。

method sqlalchemy.sql.expression.Select.limit(limit)¶

inherited from the GenerativeSelect.limit() method of GenerativeSelect

返回应用给定限制条件的新的可选值。

这是一个数值，通常呈现为 LIMIT 结果选择中的表达式。不支持的后端 LIMIT 将尝试提供类似的功能。

注解

这个 GenerativeSelect.limit() 方法将替换应用的任何子句 GenerativeSelect.fetch() .

在 1.0.0 版更改: - Select.limit() can now accept arbitrary SQL expressions as well as integer values.

参数

limit¶ -- 整数限制参数，或提供整数结果的SQL表达式。通过 None 重置它。

参见

GenerativeSelect.fetch()

GenerativeSelect.offset()

method sqlalchemy.sql.expression.Select.offset(offset)¶

inherited from the GenerativeSelect.offset() method of GenerativeSelect

返回一个新的可选择的，并应用给定的偏移标准。

这是一个数值，通常呈现为 OFFSET 结果选择中的表达式。不支持的后端 OFFSET 将尝试提供类似的功能。

在 1.0.0 版更改: - Select.offset() can now accept arbitrary SQL expressions as well as integer values.

参数

offset¶ -- 整数偏移量参数，或提供整数结果的SQL表达式。通过 None 重置它。

参见

GenerativeSelect.limit()

GenerativeSelect.fetch()

method sqlalchemy.sql.expression.Select.options(*options)¶

inherited from the Executable.options() method of Executable

将选项应用于此语句。

一般来说，options是可以由SQL编译器解释语句的任何种类的Python对象。这些选项可以由特定方言或特定种类的编译器使用。

最常见的一种选项是ORM级别的选项，它将“急切加载”和其他加载行为应用于ORM查询。然而，从理论上讲，期权可以用于许多其他目的。

有关特定类型语句的特定类型选项的背景信息，请参阅这些选项对象的文档。

在 1.4 版更改: -增加的 Generative.options() 对语句对象进行核心化，以实现统一的Core/ORM查询功能。

参见

延迟的列加载程序查询选项 -指特定于ORM查询用法的选项

与加载程序选项的关系加载 -指特定于ORM查询用法的选项

method sqlalchemy.sql.expression.Select.order_by(*clauses)¶

inherited from the GenerativeSelect.order_by() method of GenerativeSelect

返回一个新的可选择的，并应用了ORDER BY条件的给定列表。

例如。：：

stmt = select(table).order_by(table.c.id, table.c.name)

参数

*clauses¶ -- 一系列 ColumnElement 用于生成ORDER BY子句的构造。

参见

排序依据 - in the SQLAlchemy 1.4/2.0教程

按标签排序或分组 - in the SQLAlchemy 1.4/2.0教程

method sqlalchemy.sql.expression.Select.outerjoin(target, onclause=None, full=False)¶

创建左外部连接。

参数与 Select.join() .

在 1.4 版更改: Select.outerjoin() 现在创建一个 Join 对象之间 FromClause 位于现有SELECT的FROM子句中的源，以及给定的目标 FromClause ，然后添加这个 Join 新生成的SELECT语句的FROM子句。这完全是对1.3中的行为进行了修改，它将创建整个 Select 然后将该子查询连接到目标。

这是一个 向后不兼容更改 由于前面的行为基本上是无用的，因此产生了一个未命名的子查询，这在任何情况下都会被大多数数据库拒绝。新的行为是模仿那些非常成功的 Query.join() 方法，以支持 Query 通过使用 Select 对象与 Session .

有关此更改的说明，请参见 select（）.join（）和outerjoin（）将连接条件添加到当前查询，而不是创建子查询 .

参见

显式FROM子句和连接 - in the SQLAlchemy 1.4/2.0教程

联接 - in the ORM查询指南

Select.join()

method sqlalchemy.sql.expression.Select.outerjoin_from(from_, target, onclause=None, full=False)¶

针对此创建SQL LEFT OUTER JOIN Select 对象的标准，并以生成性方式应用，返回新产生的 Select 。

用法与的用法相同 Select.join_from() 。

method sqlalchemy.sql.expression.Select.prefix_with(*expr, **kw)¶

inherited from the HasPrefixes.prefix_with() method of HasPrefixes

在语句关键字后添加一个或多个表达式，即select、insert、update或delete。生成的。

这用于支持后端特定的前缀关键字，如mysql提供的前缀关键字。

例如。：：

stmt = table.insert().prefix_with("LOW_PRIORITY", dialect="mysql")

# MySQL 5.7 optimizer hints
stmt = select(table).prefix_with(
    "/*+ BKA(t1) */", dialect="mysql")

可以通过多次调用指定多个前缀 HasPrefixes.prefix_with() .

参数

• *expr¶ -- 文本或 ClauseElement 在插入、更新或删除关键字后呈现的构造。

• **kw¶ -- 只接受一个关键字“dialect”。这是一个可选的字符串方言名称，它将此前缀的呈现限制为仅显示该方言。

method sqlalchemy.sql.expression.Select.reduce_columns(only_synonyms=True)¶

返回一个新的 select() 构造具有从columns子句中删除的具有冗余名称且值相等的列。

这里的“冗余”是指两列，其中一列基于外键引用另一列，或者通过语句的WHERE子句中的简单相等比较来引用另一列。此方法的主要目的是自动构造包含所有具有唯一名称的列的SELECT语句，而不需要使用表限定名为 Select.set_label_style() 确实如此。

当根据外键省略列时，引用的列是保留的列。当根据WhereEquivalence省略列时，column s子句中的第一列就是保留的列。

参数

only_synonyms¶ -- 如果为true，则将删除列的操作限制为与等效项同名的操作。否则，将删除与另一列等效的所有列。

method sqlalchemy.sql.expression.Select.replace_selectable(old, alias)¶

inherited from the Selectable.replace_selectable() method of Selectable

替换所有出现的 FromClause “旧”与给定 Alias 对象，返回此 FromClause .

1.4 版后已移除: 这个 Selectable.replace_selectable() 方法已弃用，将在将来的版本中删除。通过sqlacalchemy.sql.visitors模块可以使用类似的功能。

method sqlalchemy.sql.expression.Select.scalar(*multiparams, **params)¶

inherited from the Executable.scalar() method of Executable

编译并执行此 Executable ，返回结果的标量表示。

1.4 版后已移除: 这个 Executable.scalar() 方法被认为是SQLAlChemy 1.x系列的遗留方法，将在2.0中删除。SQLAlChemy 2.0中的标量执行由 Connection.scalar() 一种方法 Connection ，或在ORM中由 Session.scalar() 一种方法 Session 。(有关SQLAlChemy 2.0的背景信息位于： 迁移到Alchemy )

method sqlalchemy.sql.expression.Select.scalar_subquery()¶

inherited from the SelectBase.scalar_subquery() method of SelectBase

返回此可选项的“标量”表示形式，可将其用作列表达式。

返回的对象是 ScalarSelect .

通常，只有一列的SELECT语句可以用作标量表达式。然后，可以在封闭select的where子句或columns子句中使用标量子查询。

注意，标量子查询与使用 SelectBase.subquery() 方法。

参见

标量和相关子查询 -在2.0教程中

标量选择 -在1.x教程中

method sqlalchemy.sql.expression.Select.select(*arg, **kw)¶

inherited from the SelectBase.select() method of SelectBase

1.4 版后已移除: 这个 SelectBase.select() 方法已弃用，将在将来的版本中删除；此方法隐式创建应显式的子查询。请给我打电话 SelectBase.subquery() 首先创建一个子查询，然后可以选择该子查询。

method sqlalchemy.sql.expression.Select.select_from(*froms)¶

返回一个新的 select() 构造，并将给定的FROM表达式合并到其FROM对象列表中。

例如。：：

table1 = table('t1', column('a'))
table2 = table('t2', column('b'))
s = select(table1.c.a).\
    select_from(
        table1.join(table2, table1.c.a==table2.c.b)
    )

“from”列表是每个元素标识上的唯一集合，因此添加一个已经存在的 Table 或其他可选选项将不起作用。通过A Join 指一个已经存在的 Table 或者其他可选元素具有隐藏可选元素在“从列表”中作为单个元素存在的效果，而不是将其呈现为join子句。

而典型的目的是 Select.select_from() 要用join替换派生自子句的默认值，也可以使用单个表元素调用它，如果需要，可以多次调用，如果不能从columns子句完全派生自该子句：：

select(func.count('*')).select_from(table1)

attribute sqlalchemy.sql.expression.Select.selected_columns¶

A ColumnCollection 表示此SELECT语句或类似构造在其结果集中返回的列，而不包括 TextClause 构造。

此集合与 FromClause.columns A的集合 FromClause 因为此集合中的列不能直接嵌套在另一个select语句中；必须首先应用子查询，该查询提供了SQL所需的括号。

对于 select() 构造时，此处的集合就是将在“select”语句内呈现的集合，而 ColumnElement 对象按给定方式直接存在，例如：：

col1 = column('q', Integer)
col2 = column('p', Integer)
stmt = select(col1, col2)

上图， stmt.selected_columns 将是一个集合，该集合包含 col1 和 col2 直接访问对象。对于反对 Table 或其他 FromClause ，集合将使用 ColumnElement 中的对象 FromClause.c From元素的集合。

注解

这个 Select.selected_columns 集合不包括在COLUMNS子句中使用 text() 构造；这些将从集合中静默省略。中使用纯文本列表达式 Select 构造，请使用 literal_column() 构造。

1.4 新版功能.

method sqlalchemy.sql.expression.Select.self_group(against=None)¶

根据返回“grouping”构造 ClauseElement 规范。

这将生成一个可以嵌入到表达式中的元素。请注意，在构造表达式时，此方法是根据需要自动调用的，不需要显式使用。

method sqlalchemy.sql.expression.Select.set_label_style(style)¶

inherited from the GenerativeSelect.set_label_style() method of GenerativeSelect

返回具有指定标签样式的新可选对象。

有三种“标签样式”可用， LABEL_STYLE_DISAMBIGUATE_ONLY ， LABEL_STYLE_TABLENAME_PLUS_COL ，以及 LABEL_STYLE_NONE 。默认样式为 LABEL_STYLE_TABLENAME_PLUS_COL 。

在现代SQLAlChemy中，通常不需要更改标签样式，因为通过使用 ColumnElement.label() 方法。在过去的版本中， LABEL_STYLE_TABLENAME_PLUS_COL 用于从不同的表、别名或子查询中消除同名列的歧义；较新的 LABEL_STYLE_DISAMBIGUATE_ONLY 现在，标签仅应用于与现有名称冲突的名称，因此此标签的影响最小。

消除歧义的基本原理主要是使所有列表达式都可以从给定的 FromClause.c 创建子查询时的集合。

1.4 新版功能: -The GenerativeSelect.set_label_style() 方法取代了以前的组合 .apply_labels() ， .with_labels() 和 use_labels=True 方法和/或参数。

参见

LABEL_STYLE_DISAMBIGUATE_ONLY

LABEL_STYLE_TABLENAME_PLUS_COL

LABEL_STYLE_NONE

LABEL_STYLE_DEFAULT

method sqlalchemy.sql.expression.Select.slice(start, stop)¶

inherited from the GenerativeSelect.slice() method of GenerativeSelect

基于切片对此语句应用限制/偏移量。

开始和停止索引的行为类似于python内置的参数 range() 功能。此方法提供了使用 LIMIT/OFFSET 获取查询切片。

例如：

stmt = select(User).order_by(User).id.slice(1, 3)

呈现为

SELECT users.id AS users_id,
       users.name AS users_name
FROM users ORDER BY users.id
LIMIT ? OFFSET ?
(2, 1)

注解

这个 GenerativeSelect.slice() 方法将替换应用的任何子句 GenerativeSelect.fetch() .

1.4 新版功能: 增加了 GenerativeSelect.slice() 从ORM中推广的方法。

参见

GenerativeSelect.limit()

GenerativeSelect.offset()

GenerativeSelect.fetch()

method sqlalchemy.sql.expression.Select.subquery(name=None)¶

inherited from the SelectBase.subquery() method of SelectBase

返回此的子查询 SelectBase .

从SQL的角度来看，子查询是一个带圆括号的命名构造，它可以放在另一个SELECT语句的from子句中。

给出了如下select语句：

stmt = select(table.c.id, table.c.name)

上面的语句可能如下所示：

SELECT table.id, table.name FROM table

子查询表单本身呈现的方式相同，但是当嵌入到另一个select语句的from子句中时，它将成为一个命名的子元素：：

subq = stmt.subquery()
new_stmt = select(subq)

上面呈现为：

SELECT anon_1.id, anon_1.name
FROM (SELECT table.id, table.name FROM table) AS anon_1

历史上， SelectBase.subquery() 相当于调用 FromClause.alias() 方法；但是，作为 SelectBase 对象不是直接来自对象，而是 SelectBase.subquery() 方法提供了更清晰的语义。

1.4 新版功能.

method sqlalchemy.sql.expression.Select.suffix_with(*expr, **kw)¶

inherited from the HasSuffixes.suffix_with() method of HasSuffixes

在语句后面整体添加一个或多个表达式。

这用于在某些构造上支持后端特定的后缀关键字。

例如。：：

stmt = select(col1, col2).cte().suffix_with(
    "cycle empno set y_cycle to 1 default 0", dialect="oracle")

可以通过多次调用指定多个后缀 HasSuffixes.suffix_with() .

参数

• *expr¶ -- 文本或 ClauseElement 在目标子句之后呈现的构造。

• **kw¶ -- 只接受一个关键字“dialect”。这是一个可选的字符串方言名称，它将此后缀的呈现限制为仅限于该方言。

method sqlalchemy.sql.expression.Select.union(other, **kwargs)¶

返回SQL UNION 此select（）构造的。

method sqlalchemy.sql.expression.Select.union_all(other, **kwargs)¶

返回SQL UNION ALL 此select（）构造的。

method sqlalchemy.sql.expression.Select.where(*whereclause)¶

返回一个新的 select() 将给定表达式添加到其WHERE子句中，并通过AND（如果有）连接到现有子句。

attribute sqlalchemy.sql.expression.Select.whereclause¶

为此返回已完成的WHERE子句 Select 语句。

这将把WHERE条件的当前集合组合成一个 BooleanClauseList 构造。

1.4 新版功能.

method sqlalchemy.sql.expression.Select.with_for_update(nowait=False, read=False, of=None, skip_locked=False, key_share=False)¶

inherited from the GenerativeSelect.with_for_update() method of GenerativeSelect

指定一个 FOR UPDATE 此条款 GenerativeSelect .

例如。：：

stmt = select(table).with_for_update(nowait=True)

在PostgreSQL或Oracle这样的数据库上，上面的语句将呈现如下：

SELECT table.a, table.b FROM table FOR UPDATE NOWAIT

在其他后端， nowait 选项被忽略，将生成：：

SELECT table.a, table.b FROM table FOR UPDATE

当不带参数调用时，该语句将以后缀呈现 FOR UPDATE . 然后可以提供其他参数，以允许常见的特定于数据库的变量。

参数

• nowait¶ -- 布尔值；将呈现 FOR UPDATE NOWAIT 关于Oracle和PostgreSQL方言。

• read¶ -- 布尔值；将呈现 LOCK IN SHARE MODE 关于MySQL， FOR SHARE 在PostgreSQL上。在PostgreSQL上，当与 nowait 将渲染 FOR SHARE NOWAIT .

• of¶ -- SQL表达式或SQL表达式元素列表（通常 Column 对象或兼容表达式），它将呈现为 FOR UPDATE OF 子句；由PostgreSQL和Oracle支持。可以呈现为表或列，具体取决于后端。

• skip_locked¶ -- 布尔值，将呈现 FOR UPDATE SKIP LOCKED 关于Oracle和PostgreSQL方言或 FOR SHARE SKIP LOCKED 如果 read=True 也指定了。

• key_share¶ -- 布尔值，将呈现 FOR NO KEY UPDATE ，或者如果与 read=True 将渲染 FOR KEY SHARE 在PostgreSQL方言上。

method sqlalchemy.sql.expression.Select.with_hint(selectable, text, dialect_name='*')¶

inherited from the HasHints.with_hint() method of HasHints

为给定的可选对象添加索引或其他执行上下文提示 Select 或其他可选对象。

提示的文本呈现在正在使用的数据库后端的适当位置，相对于给定的 Table 或 Alias 作为传递 selectable 争论。方言实现通常使用带有标记的python字符串替换语法 %(name)s 呈现表或别名的名称。例如，使用Oracle时，以下内容：

select(mytable).\
    with_hint(mytable, "index(%(name)s ix_mytable)")

将SQL呈现为：

select /*+ index(mytable ix_mytable) */ ... from mytable

这个 dialect_name 选项将把特定提示的呈现限制到特定的后端。例如，要同时为Oracle和Sybase添加提示：

select(mytable).\
    with_hint(mytable, "index(%(name)s ix_mytable)", 'oracle').\
    with_hint(mytable, "WITH INDEX ix_mytable", 'sybase')

参见

Select.with_statement_hint()

method sqlalchemy.sql.expression.Select.with_only_columns(*columns, **kw)¶

返回一个新的 select() 用它的columns子句替换给定的列来构造。

默认情况下，此方法完全等同于原始 select() 已使用给定的COLUMNS子句调用。例如，声明：：

s = select(table1.c.a, table1.c.b)
s = s.with_only_columns(table1.c.b)

应完全等同于：

s = select(table1.c.b)

在此操作模式中， Select.with_only_columns() 如果没有显式声明，还将动态更改语句的FROM子句。若要维护现有的FORM集(包括CURRENT COLUMNS子句所暗示的FROM)，请添加 Select.with_only_columns.maintain_column_froms 参数：：

s = select(table1.c.a, table2.c.b)
s = s.with_only_columns(table1.c.a, maintain_column_froms=True)

上面的参数执行将Columns集合中的有效FORM传输到 Select.select_from() 方法，就好像调用了以下内容：

s = select(table1.c.a, table2.c.b)
s = s.select_from(table1, table2).with_only_columns(table1.c.a)

这个 Select.with_only_columns.maintain_column_froms 参数利用 Select.columns_clause_froms 集合，并执行与以下内容等效的操作：

s = select(table1.c.a, table2.c.b)
s = s.select_from(*s.columns_clause_froms).with_only_columns(table1.c.a)

参数

• *columns¶ -- 要使用的列表达式。。。版本已更改：：1.4 Select.with_only_columns() 方法按位置接受列表达式列表；不推荐将表达式作为列表传递。

• maintain_column_froms¶ -- 布尔参数，该参数将确保从CURRENT COLUMNS子句隐含的FROM列表将传输到 Select.select_from() 方法先行。。。添加的版本：：1.4.23

method sqlalchemy.sql.expression.Select.with_statement_hint(text, dialect_name='*')¶

inherited from the HasHints.with_statement_hint() method of HasHints

为此添加语句提示 Select 或其他可选对象。

这种方法类似于 Select.with_hint() 但它不需要单独的表，而是作为一个整体应用于语句。

这里的提示特定于后端数据库，可能包括诸如隔离级别、文件指令、fetch指令等指令。

1.0.0 新版功能.

参见

Select.with_hint()

Select.prefix_with() -通用的SELECT前缀，也可以适合一些数据库特定的提示语法，如MySQL优化器提示