Release: 1.4.25 | Release Date: September 22, 2021

SQLAlchemy 1.4 Documentation

可选择文件、表格、来自对象

术语“可选”是指可以从中选择行的任何对象;在SQLAlchemy中,这些对象从 FromClause 它们的特点是 FromClause.c 属性,它是FROM子句中包含的所有列的命名空间(这些元素本身 ColumnElement 子类)。

可选择的基础构造函数

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

Object Name Description

except_(*selects, **kwargs)

返回一 EXCEPT 多个可选择的。

except_all(*selects, **kwargs)

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

exists(*args, **kwargs)

构建新的 Exists 构造。

intersect(*selects, **kwargs)

返回一 INTERSECT 多个可选择的。

intersect_all(*selects, **kwargs)

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

select(*args, **kw)

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

table(name, *columns, **kw)

产生新的 TableClause .

union(*selects, **kwargs)

返回A UNION 多个可选择的。

union_all(*selects, **kwargs)

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

values(*columns, **kw)

构建一个 Values 构造。

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 (典型地 TableAlias 对象) 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输出中以内联方式呈现数据值,而不是使用绑定参数。

可选修改器构造函数

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

Object Name Description

alias(selectable[, name, flat])

返回一 Alias 对象。

cte(selectable[, name, recursive])

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

join(left, right[, onclause, isouter, ...])

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

lateral(selectable[, name])

返回A Lateral 对象。

outerjoin(left, right[, onclause, full])

返回一 OUTER JOIN 子句元素。

tablesample(selectable, sampling[, name, seed])

返回A TableSample 对象。

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表达式。如果留在 NoneFromClause.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表达式。如有规定,还应提供可重复的子条款。

可选课程文档

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

Object Name Description

Alias

表示表或可选别名(as)。

AliasedReturnsRows

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

CompoundSelect

构成 UNIONUNION ALL ,以及其他基于SELECT的set操作。

CTE

表示公用表表达式。

Executable

马克A ClauseElement 作为支持执行。

Exists

代表 EXISTS 条款。

FromClause

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

GenerativeSelect

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

HasCTE

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

HasPrefixes

HasSuffixes

Join

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

Lateral

表示横向子查询。

ReturnsRows

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

ScalarSelect

表示标量子查询。

Select

表示 SELECT 语句。

Selectable

将类标记为可选择的。

SelectBase

select语句的基类。

Subquery

表示select的子查询。

TableClause

表示最小的“表”构造。

TableSample

表示tablesample子句。

TableValuedAlias

“表值”SQL函数的别名。

TextualSelect

包装一个 TextClause 在一个 SelectBase 接口。

Values

代表一个 VALUES 构造,它可以用作语句中的FROM元素。

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

表示表或可选别名(as)。

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

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

类签名

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)

构成 UNIONUNION ALL ,以及其他基于SELECT的set操作。

类签名

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

attribute sqlalchemy.sql.expression.CompoundSelect.bind

返回 EngineConnection 对此 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语句的选定列。

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 构造,例如 InsertUpdateDelete . 见 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() 方法。

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

返回 EngineConnection 对此 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() 完整的选项列表。

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

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

1.3 新版功能.

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() 关于用法的描述。

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

构建新的 Exists 对象。

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

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

将关联应用于 Exists .

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

将关联应用于 Exists .

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
参数

参见

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 语句。

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

类签名

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子句。

attribute sqlalchemy.sql.expression.FromClause.c

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

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

返回

ColumnCollection

attribute sqlalchemy.sql.expression.FromClause.columns

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

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 新版功能.

attribute sqlalchemy.sql.expression.FromClause.foreign_keys

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

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

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表达式。如果留在 NoneFromClause.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表达式。如果留在 NoneFromClause.join() 将尝试基于外键关系联接两个表。

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

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)
参数

参见

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 新版功能.

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语句的基类。

这是 SelectCompoundSelect 其中可以添加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 -- 什么时候? Truecount 表示要返回的选定行总数的百分比。默认为 False

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子句的构造。

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 重置它。

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 重置它。

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子句的构造。

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

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

有三种“标签样式”可用, LABEL_STYLE_DISAMBIGUATE_ONLYLABEL_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 方法和/或参数。

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中推广的方法。

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

类签名

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 并返回这两个可选择项的联接。这将生成不包含封闭选择的联接表达式。

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
参数
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.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 新版功能.

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映射类)将成为相关集合的一部分。

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

返回 EngineConnection 对此 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.cSelectBase.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映射类)将成为相关集合的一部分。

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

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

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

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

参数

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

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 通过一个共同的祖先列。

参数

参见

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() .

参数
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() 完整的选项列表。

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 新版功能.

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 -- 什么时候? Truecount 表示要返回的选定行总数的百分比。默认为 False

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 新版功能.

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 访问器,它已弃用。

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

检索当前标签样式。

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子句的构造。

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,则生成完整的外部联接。

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,则生成完整的外部联接。

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

inherited from the SelectBase.label() method of SelectBase

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

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 重置它。

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 重置它。

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子句的构造。

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()将连接条件添加到当前查询,而不是创建子查询 .

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 将是一个集合,该集合包含 col1col2 直接访问对象。对于反对 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)

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

有三种“标签样式”可用, LABEL_STYLE_DISAMBIGUATE_ONLYLABEL_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 方法和/或参数。

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中推广的方法。

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)

指定一个 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 或其他可选对象。

提示的文本呈现在正在使用的数据库后端的适当位置,相对于给定的 TableAlias 作为传递 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')
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优化器提示

class sqlalchemy.sql.expression.Selectable

将类标记为可选择的。

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

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

参数

参见

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

ColumnCollection.corresponding_column() -实施方法。

attribute sqlalchemy.sql.expression.Selectable.exported_columns

inherited from the ReturnsRows.exported_columns attribute of ReturnsRows

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

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

1.4 新版功能.

method sqlalchemy.sql.expression.Selectable.lateral(name=None)

返回此的横向别名 Selectable .

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

1.1 新版功能.

参见

横向相关 -使用概述。

method sqlalchemy.sql.expression.Selectable.replace_selectable(old, alias)

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

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

class sqlalchemy.sql.expression.SelectBase

select语句的基类。

这包括 SelectCompoundSelectTextualSelect .

类签名

class sqlalchemy.sql.expression.SelectBase (sqlalchemy.sql.roles.SelectStatementRole, sqlalchemy.sql.roles.DMLSelectRole, sqlalchemy.sql.roles.CompoundElementRole, sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.expression.HasCTE, sqlalchemy.sql.expression.Executable, sqlalchemy.sql.annotation.SupportsCloneAnnotations, sqlalchemy.sql.expression.Selectable)

method sqlalchemy.sql.expression.SelectBase.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.SelectBase.alias(name=None, flat=False)

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

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

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

method sqlalchemy.sql.expression.SelectBase.as_scalar()

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

attribute sqlalchemy.sql.expression.SelectBase.bind

inherited from the Executable.bind attribute of Executable

返回 EngineConnection 对此 Executable 是绑定的,如果未找到,则为无。

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

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

attribute sqlalchemy.sql.expression.SelectBase.c

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

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

inherited from the Selectable.corresponding_column() method of Selectable

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

参数

参见

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

ColumnCollection.corresponding_column() -实施方法。

method sqlalchemy.sql.expression.SelectBase.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.SelectBase.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.SelectBase.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() 完整的选项列表。

method sqlalchemy.sql.expression.SelectBase.exists()

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

返回的对象是 Exists .

参见

exists()

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

1.4 新版功能.

attribute sqlalchemy.sql.expression.SelectBase.exported_columns

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

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

1.4 新版功能.

method sqlalchemy.sql.expression.SelectBase.get_execution_options()

inherited from the Executable.get_execution_options() method of Executable

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

1.3 新版功能.

method sqlalchemy.sql.expression.SelectBase.label(name)

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

method sqlalchemy.sql.expression.SelectBase.lateral(name=None)

返回此的横向别名 Selectable .

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

1.1 新版功能.

参见

横向相关 -使用概述。

method sqlalchemy.sql.expression.SelectBase.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.SelectBase.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.SelectBase.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.SelectBase.scalar_subquery()

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

返回的对象是 ScalarSelect .

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

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

参见

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

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

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

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

attribute sqlalchemy.sql.expression.SelectBase.selected_columns

A ColumnCollection 表示此select语句或类似构造在其结果集中返回的列。

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

注解

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

1.4 新版功能.

method sqlalchemy.sql.expression.SelectBase.subquery(name=None)

返回此的子查询 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 新版功能.

class sqlalchemy.sql.expression.Subquery(*arg, **kw)

表示select的子查询。

A Subquery 通过调用 SelectBase.subquery() 方法,或为了方便 SelectBase.alias() 方法,任何 SelectBase 子类,包括 SelectCompoundSelectTextualSelect .正如在FROM子句中呈现的那样,它表示括号内select语句的主体,后跟通常定义所有“alias”对象的“as<somename>”。

这个 Subquery 对象与 Alias 对象和可以以等效的方式使用。两者之间的区别 AliasSubquery 那是 Alias 始终包含 FromClause 反对,鉴于 Subquery 始终包含 SelectBase 对象。

1.4 新版功能: 这个 Subquery 添加了类,该类现在用于提供select语句的别名版本。

method sqlalchemy.sql.expression.Subquery.as_scalar()

1.4 版后已移除: 这个 Subquery.as_scalar() 方法,以前是 Alias.as_scalar() 在1.4版之前,已弃用,将在将来的版本中删除;请使用 Select.scalar_subquery() 方法 select() 在构造子查询对象之前构造,或使用ORM使用 Query.scalar_subquery() 方法。

class sqlalchemy.sql.expression.TableClause(name, *columns, **kw)

表示最小的“表”构造。

这是一个轻量级表对象,它只有一个名称,一组列,这些列通常由 column() 函数和模式:

from sqlalchemy import table, column

user = table("user",
        column("id"),
        column("name"),
        column("description"),
)

这个 TableClause 构造是更常用的 Table 对象,提供 FromClause 服务包括 .c. 集合和语句生成方法。

它确实 not 提供的所有其他架构级服务 Table ,包括约束、对其他表的引用或对 MetaData -水平服务。它本身作为一个特别的构造非常有用,用于在更成熟的时候生成快速的SQL语句 Table 不在手边。

类签名

class sqlalchemy.sql.expression.TableClause (sqlalchemy.sql.roles.DMLTableRole, sqlalchemy.sql.expression.Immutable, sqlalchemy.sql.expression.FromClause)

method sqlalchemy.sql.expression.TableClause.__init__(name, *columns, **kw)

构建新的 TableClause 对象。

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

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

inherited from the FromClause.alias() method of FromClause

返回此的别名 FromClause .

例如。::

a2 = some_table.alias('a2')

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

attribute sqlalchemy.sql.expression.TableClause.c

inherited from the FromClause.c attribute of FromClause

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

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

返回

ColumnCollection

attribute sqlalchemy.sql.expression.TableClause.columns

inherited from the FromClause.columns attribute of FromClause

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

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::

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

ColumnCollection 对象。

method sqlalchemy.sql.expression.TableClause.compare(other, **kw)

inherited from the ClauseElement.compare() method of ClauseElement

比较一下 ClauseElement 到给定的 ClauseElement .

子类应该覆盖默认行为,这是一个直接的身份比较。

* *kw是子类消耗的参数 compare() 方法和可用于修改比较标准(请参见 ColumnElement

method sqlalchemy.sql.expression.TableClause.compile(bind=None, dialect=None, **kw)

inherited from the ClauseElement.compile() method of ClauseElement

编译此SQL表达式。

返回值为 Compiled 对象。打电话 str()unicode() 返回的值将生成结果的字符串表示形式。这个 Compiled 对象还可以返回绑定参数名称和值的字典,方法是 params 访问器。

参数
  • bind -- 安 EngineConnection 从哪一个 Compiled 将被收购。此参数优先于此 ClauseElement 如果有绑定的引擎。

  • column_keys -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None ,将呈现目标表对象中的所有列。

  • dialect -- A Dialect 实例,其中 Compiled 将被收购。此参数优先于 bind argument as well as this :class:`_ 子句元素表达式`如果有的话。

  • compile_kwargs -- 附加参数的可选字典,这些参数将在所有“访问”方法中传递给编译器。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于传递 literal_binds 标志通过:FROM sqlalChemy.sql导入表,列,SELECT t=TABLE(‘t’,COLUMN(‘x’))s=SELECT(T).WHERE(t.c.x==5)print(s.compile(compile_kwargs={“literal_binds”:True}))..添加的版本::0.9.0

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

inherited from the Selectable.corresponding_column() method of Selectable

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

参数

参见

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

ColumnCollection.corresponding_column() -实施方法。

method sqlalchemy.sql.expression.TableClause.delete(whereclause=None, **kwargs)

生成一个 delete() 在此基础上构建 TableClause .

例如。::

table.delete().where(table.c.id==7)

delete() 获取参数和用法信息。

attribute sqlalchemy.sql.expression.TableClause.description
attribute sqlalchemy.sql.expression.TableClause.entity_namespace

inherited from the FromClause.entity_namespace attribute of FromClause

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

这是用于解析“filter_by()”类型表达式的命名空间,例如:

stmt.filter_by(address='some address')

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

attribute sqlalchemy.sql.expression.TableClause.exported_columns

inherited from the FromClause.exported_columns attribute of FromClause

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

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

1.4 新版功能.

attribute sqlalchemy.sql.expression.TableClause.foreign_keys

inherited from the FromClause.foreign_keys attribute of FromClause

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

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

method sqlalchemy.sql.expression.TableClause.get_children(omit_attrs=(), **kw)

inherited from the Traversible.get_children() method of Traversible

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

用于访问遍历。

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

attribute sqlalchemy.sql.expression.TableClause.implicit_returning = False

TableClause 不支持主键或列级默认值,因此隐式返回不适用。

method sqlalchemy.sql.expression.TableClause.insert(values=None, inline=False, **kwargs)

生成 insert() 在此基础上构建 TableClause .

例如。::

table.insert().values(name='foo')

insert() 获取参数和用法信息。

method sqlalchemy.sql.expression.TableClause.is_derived_from(fromclause)

inherited from the FromClause.is_derived_from() method of FromClause

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

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

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

inherited from the FromClause.join() method of FromClause

返回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表达式。如果留在 NoneFromClause.join() 将尝试基于外键关系联接两个表。

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

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

参见

join() -独立函数

Join -生成的对象类型

method sqlalchemy.sql.expression.TableClause.lateral(name=None)

inherited from the Selectable.lateral() method of Selectable

返回此的横向别名 Selectable .

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

1.1 新版功能.

参见

横向相关 -使用概述。

class memoized_attribute(fget, doc=None)

只读@属性,只计算一次。

method sqlalchemy.sql.expression.TableClause.classmethod memoized_instancemethod(fn)

inherited from the HasMemoized.memoized_instancemethod() method of HasMemoized

装饰一个方法记下它的返回值。

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

inherited from the FromClause.outerjoin() method of FromClause

返回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表达式。如果留在 NoneFromClause.join() 将尝试基于外键关系联接两个表。

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

method sqlalchemy.sql.expression.TableClause.params(*optionaldict, **kwargs)

inherited from the Immutable.params() method of Immutable

返回副本 bindparam() 元素被替换。

返回此条款的副本 bindparam() 用给定字典中的值替换的元素::

>>> clause = column('x') + bindparam('foo')
>>> print(clause.compile().params)
{'foo':None}
>>> print(clause.params({'foo':7}).compile().params)
{'foo':7}
attribute sqlalchemy.sql.expression.TableClause.primary_key

inherited from the FromClause.primary_key attribute of FromClause

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

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

method sqlalchemy.sql.expression.TableClause.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.TableClause.select(whereclause=None, **kwargs)

inherited from the FromClause.select() method of FromClause

返回此选项 FromClause .

例如。::

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

参见

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

method sqlalchemy.sql.expression.TableClause.self_group(against=None)

inherited from the ClauseElement.self_group() method of ClauseElement

对此应用“分组” ClauseElement .

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

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

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

method sqlalchemy.sql.expression.TableClause.table_valued()

inherited from the FromClause.table_valued() method of FromClause

返回一个 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 新版功能.

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

inherited from the FromClause.tablesample() method of FromClause

返回此的TableSample别名 FromClause .

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

1.1 新版功能.

参见

tablesample() -使用指南和参数

method sqlalchemy.sql.expression.TableClause.unique_params(*optionaldict, **kwargs)

inherited from the Immutable.unique_params() method of Immutable

返回副本 bindparam() 元素被替换。

功能与 ClauseElement.params() ,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。

method sqlalchemy.sql.expression.TableClause.update(whereclause=None, values=None, inline=False, **kwargs)

生成 update() 在此基础上构建 TableClause .

例如。::

table.update().where(table.c.id==7).values(name='foo')

update() 获取参数和用法信息。

class sqlalchemy.sql.expression.TableSample(*arg, **kw)

表示tablesample子句。

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

1.1 新版功能.

参见

tablesample()

class sqlalchemy.sql.expression.TableValuedAlias(*arg, **kw)

“表值”SQL函数的别名。

此构造提供一个SQL函数,该函数返回SELECT语句的FROM子句中要使用的列。该对象是使用 FunctionElement.table_valued() 方法,例如::

>>> from sqlalchemy import select, func
>>> fn = func.json_array_elements_text('["one", "two", "three"]').table_valued("value")
>>> print(select(fn.c.value))
SELECT anon_1.value
FROM json_array_elements_text(:json_array_elements_text_1) AS anon_1

1.4.0b2 新版功能.

method sqlalchemy.sql.expression.TableValuedAlias.alias(name=None)

返回此文件的新别名 TableValuedAlias

这将创建一个DISTINCT FROM对象,该对象在SQL语句中使用时将有别于原始对象。

attribute sqlalchemy.sql.expression.TableValuedAlias.column

返回表示以下内容的列表达式 TableValuedAlias

此访问器用于实现 FunctionElement.column_valued() 方法。有关详细信息,请参阅该方法。

例如。::

>>> print(select(func.some_func().table_valued("value").column))
SELECT anon_1 FROM some_func() AS anon_1
method sqlalchemy.sql.expression.TableValuedAlias.lateral(name=None)

返回一个新的 TableValuedAlias 设置了横向标志,以便它呈现为横向。

参见

lateral()

method sqlalchemy.sql.expression.TableValuedAlias.render_derived(name=None, with_types=False)

将“渲染派生”应用于此 TableValuedAlias

这将影响在“As”序列中别名之后列出的单个列名,例如::

>>> print(
...     select(
...         func.unnest(array(["one", "two", "three"])).
            table_valued("x", with_ordinality="o").render_derived()
...     )
... )
SELECT anon_1.x, anon_1.o
FROM unnest(ARRAY[%(param_1)s, %(param_2)s, %(param_3)s]) WITH ORDINALITY AS anon_1(x, o)

这个 with_types 关键字将在别名表达式内内联呈现列类型(此语法当前适用于PostgreSQL数据库):

>>> print(
...     select(
...         func.json_to_recordset(
...             '[{"a":1,"b":"foo"},{"a":"2","c":"bar"}]'
...         )
...         .table_valued(column("a", Integer), column("b", String))
...         .render_derived(with_types=True)
...     )
... )
SELECT anon_1.a, anon_1.b FROM json_to_recordset(:json_to_recordset_1)
AS anon_1(a INTEGER, b VARCHAR)
参数
  • name -- 将应用于生成的别名的可选字符串名称。如果保留为None,则将使用唯一的匿名名称。

  • with_types -- 如果为True,则派生列将在每列中包含数据类型规范。这是目前已知的PostgreSQL对于某些SQL函数所需的特殊语法。

class sqlalchemy.sql.expression.TextualSelect(text, columns, positional=False)

包装一个 TextClause 在一个 SelectBase 接口。

这允许 TextClause 要获得的对象 .c 收集和其他类似功能,例如 FromClause.alias()SelectBase.cte() 等。

这个 TextualSelect 构造是通过 TextClause.columns() 方法-有关详细信息,请参见该方法。

在 1.4 版更改: 这个 TextualSelect 类已从重命名 TextAsFrom ,以便更正确地适应它作为面向选择的对象而不是FROM子句的角色。

参见

text()

TextClause.columns() -主要创建界面。

method sqlalchemy.sql.expression.TextualSelect.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.TextualSelect.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.TextualSelect.as_scalar()

inherited from the SelectBase.as_scalar() method of SelectBase

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

attribute sqlalchemy.sql.expression.TextualSelect.bind

inherited from the Executable.bind attribute of Executable

返回 EngineConnection 对此 Executable 是绑定的,如果未找到,则为无。

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

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

attribute sqlalchemy.sql.expression.TextualSelect.c

inherited from the SelectBase.c attribute of SelectBase

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

method sqlalchemy.sql.expression.TextualSelect.compare(other, **kw)

inherited from the ClauseElement.compare() method of ClauseElement

比较一下 ClauseElement 到给定的 ClauseElement .

子类应该覆盖默认行为,这是一个直接的身份比较。

* *kw是子类消耗的参数 compare() 方法和可用于修改比较标准(请参见 ColumnElement

method sqlalchemy.sql.expression.TextualSelect.compile(bind=None, dialect=None, **kw)

inherited from the ClauseElement.compile() method of ClauseElement

编译此SQL表达式。

返回值为 Compiled 对象。打电话 str()unicode() 返回的值将生成结果的字符串表示形式。这个 Compiled 对象还可以返回绑定参数名称和值的字典,方法是 params 访问器。

参数
  • bind -- 安 EngineConnection 从哪一个 Compiled 将被收购。此参数优先于此 ClauseElement 如果有绑定的引擎。

  • column_keys -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None ,将呈现目标表对象中的所有列。

  • dialect -- A Dialect 实例,其中 Compiled 将被收购。此参数优先于 bind argument as well as this :class:`_ 子句元素表达式`如果有的话。

  • compile_kwargs -- 附加参数的可选字典,这些参数将在所有“访问”方法中传递给编译器。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于传递 literal_binds 标志通过:FROM sqlalChemy.sql导入表,列,SELECT t=TABLE(‘t’,COLUMN(‘x’))s=SELECT(T).WHERE(t.c.x==5)print(s.compile(compile_kwargs={“literal_binds”:True}))..添加的版本::0.9.0

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

inherited from the Selectable.corresponding_column() method of Selectable

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

参数

参见

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

ColumnCollection.corresponding_column() -实施方法。

method sqlalchemy.sql.expression.TextualSelect.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.TextualSelect.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.TextualSelect.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() 完整的选项列表。

method sqlalchemy.sql.expression.TextualSelect.exists()

inherited from the SelectBase.exists() method of SelectBase

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

返回的对象是 Exists .

参见

exists()

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

1.4 新版功能.

attribute sqlalchemy.sql.expression.TextualSelect.exported_columns

inherited from the SelectBase.exported_columns attribute of SelectBase

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

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

1.4 新版功能.

method sqlalchemy.sql.expression.TextualSelect.get_children(omit_attrs=(), **kw)

inherited from the Traversible.get_children() method of Traversible

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

用于访问遍历。

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

method sqlalchemy.sql.expression.TextualSelect.get_execution_options()

inherited from the Executable.get_execution_options() method of Executable

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

1.3 新版功能.

method sqlalchemy.sql.expression.TextualSelect.label(name)

inherited from the SelectBase.label() method of SelectBase

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

method sqlalchemy.sql.expression.TextualSelect.lateral(name=None)

inherited from the SelectBase.lateral() method of SelectBase

返回此的横向别名 Selectable .

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

1.1 新版功能.

参见

横向相关 -使用概述。

class memoized_attribute(fget, doc=None)

只读@属性,只计算一次。

method sqlalchemy.sql.expression.TextualSelect.classmethod memoized_instancemethod(fn)

inherited from the HasMemoized.memoized_instancemethod() method of HasMemoized

装饰一个方法记下它的返回值。

method sqlalchemy.sql.expression.TextualSelect.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.TextualSelect.params(*optionaldict, **kwargs)

inherited from the ClauseElement.params() method of ClauseElement

返回副本 bindparam() 元素被替换。

返回此条款的副本 bindparam() 用给定字典中的值替换的元素::

>>> clause = column('x') + bindparam('foo')
>>> print(clause.compile().params)
{'foo':None}
>>> print(clause.params({'foo':7}).compile().params)
{'foo':7}
method sqlalchemy.sql.expression.TextualSelect.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.TextualSelect.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.TextualSelect.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.TextualSelect.select(*arg, **kw)

inherited from the SelectBase.select() method of SelectBase

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

attribute sqlalchemy.sql.expression.TextualSelect.selected_columns

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

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

对于一个 TextualSelect 构造,集合包含 ColumnElement 传递给构造函数的对象,通常通过 TextClause.columns() 方法。

1.4 新版功能.

method sqlalchemy.sql.expression.TextualSelect.self_group(against=None)

inherited from the ClauseElement.self_group() method of ClauseElement

对此应用“分组” ClauseElement .

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

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

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

method sqlalchemy.sql.expression.TextualSelect.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.TextualSelect.unique_params(*optionaldict, **kwargs)

inherited from the ClauseElement.unique_params() method of ClauseElement

返回副本 bindparam() 元素被替换。

功能与 ClauseElement.params() ,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。

class sqlalchemy.sql.expression.Values(*columns, **kw)

代表一个 VALUES 构造,它可以用作语句中的FROM元素。

这个 Values 从对象创建 values() 功能。

1.4 新版功能.

类签名

class sqlalchemy.sql.expression.Values (sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.FromClause)

method sqlalchemy.sql.expression.Values.__init__(*columns, **kw)

构建新的 Values 对象。

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

method sqlalchemy.sql.expression.Values.alias(name, **kw)

返回一个新的 Values 构造一个具有给定名称的副本。

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

method sqlalchemy.sql.expression.Values.data(values)

返回一个新的 Values 构造,将给定的数据添加到数据列表中。

例如。::

my_values = my_values.data([(1, 'value 1'), (2, 'value2')])
参数

values -- 映射到中给定的列表达式的元组序列(即列表) Values 建造师。

method sqlalchemy.sql.expression.Values.lateral(name=None)

返回一个新的 Values 设置侧旗,使其渲染为侧向。

参见

lateral()

标签样式常量

与一起使用的常量 GenerativeSelect.set_label_style() 方法。

Object Name Description

LABEL_STYLE_DEFAULT

默认标签样式,指的是 LABEL_STYLE_DISAMBIGUATE_ONLY

LABEL_STYLE_DISAMBIGUATE_ONLY

标签样式,指示在生成SELECT语句的COLUMNS子句时,名称与现有名称冲突的列应该使用半匿名标签进行标记。

LABEL_STYLE_NONE

指示没有自动标签的标签样式应应用于SELECT语句的COLUMNS子句。

LABEL_STYLE_TABLENAME_PLUS_COL

指示所有列的标签样式应标记为 <tablename>_<columnname> 在生成SELECT语句的COLUMNS子句时,消除从不同表、别名或子查询引用的同名列的歧义。

sqlalchemy.sql.expression.LABEL_STYLE_DISAMBIGUATE_ONLY = symbol('LABEL_STYLE_DISAMBIGUATE_ONLY')

标签样式,指示在生成SELECT语句的COLUMNS子句时,名称与现有名称冲突的列应该使用半匿名标签进行标记。

下面,除了名称的第二次出现之外,大多数列名都不受影响 columna ,它是使用标签来标记的 columna_1 以消除它与…的歧义 tablea.columna ::

>>> from sqlalchemy import table, column, select, true, LABEL_STYLE_DISAMBIGUATE_ONLY
>>> table1 = table("table1", column("columna"), column("columnb"))
>>> table2 = table("table2", column("columna"), column("columnc"))
>>> print(select(table1, table2).join(table2, true()).set_label_style(LABEL_STYLE_DISAMBIGUATE_ONLY))
SELECT table1.columna, table1.columnb, table2.columna AS columna_1, table2.columnc
FROM table1 JOIN table2 ON true

GenerativeSelect.set_label_style() 方法, LABEL_STYLE_DISAMBIGUATE_ONLY 是所有SELECT语句的默认标签样式 1.x style ORM查询。

1.4 新版功能.

sqlalchemy.sql.expression.LABEL_STYLE_NONE = symbol('LABEL_STYLE_NONE')

指示没有自动标签的标签样式应应用于SELECT语句的COLUMNS子句。

下面是名为 columna 都是按原样呈现的,这意味着该名称 columna 只能引用此名称在结果集中的第一个匹配项,以及语句是否用作子查询::

>>> from sqlalchemy import table, column, select, true, LABEL_STYLE_NONE
>>> table1 = table("table1", column("columna"), column("columnb"))
>>> table2 = table("table2", column("columna"), column("columnc"))
>>> print(select(table1, table2).join(table2, true()).set_label_style(LABEL_STYLE_NONE))
SELECT table1.columna, table1.columnb, table2.columna, table2.columnc
FROM table1 JOIN table2 ON true

Select.set_label_style() 方法。

1.4 新版功能.

sqlalchemy.sql.expression.LABEL_STYLE_TABLENAME_PLUS_COL = symbol('LABEL_STYLE_TABLENAME_PLUS_COL')

指示所有列的标签样式应标记为 <tablename>_<columnname> 在生成SELECT语句的COLUMNS子句时,消除从不同表、别名或子查询引用的同名列的歧义。

下面,所有列名都被赋予一个标签,以便两个同名的列 columna 已消除歧义,如下所示 table1_columna``table2_columna` ::

>>> from sqlalchemy import table, column, select, true, LABEL_STYLE_TABLENAME_PLUS_COL
>>> table1 = table("table1", column("columna"), column("columnb"))
>>> table2 = table("table2", column("columna"), column("columnc"))
>>> print(select(table1, table2).join(table2, true()).set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL))
SELECT table1.columna AS table1_columna, table1.columnb AS table1_columnb, table2.columna AS table2_columna, table2.columnc AS table2_columnc
FROM table1 JOIN table2 ON true

GenerativeSelect.set_label_style() 方法。等同于遗留方法 Select.apply_labels()LABEL_STYLE_TABLENAME_PLUS_COL 是SQLAlChemy的遗留自动标签样式。 LABEL_STYLE_DISAMBIGUATE_ONLY 提供了一种干扰较小的方法来消除同名列表达式的歧义。

1.4 新版功能.

sqlalchemy.sql.expression.LABEL_STYLE_DEFAULT

默认标签样式,指的是 LABEL_STYLE_DISAMBIGUATE_ONLY

1.4 新版功能.

Previous: 操作员参考 Next: 插入、更新、删除