术语“可选”是指可以从中选择行的任何对象;在SQLAlchemy中,这些对象从 FromClause
它们的特点是 FromClause.c
属性,它是FROM子句中包含的所有列的命名空间(这些元素本身 ColumnElement
子类)。
顶层的“FROM子句”和“SELECT”构造函数。
Object Name | Description |
---|---|
except_(*selects, **kwargs) |
返回一 |
except_all(*selects, **kwargs) |
返回一 |
exists(*args, **kwargs) |
构建新的 |
intersect(*selects, **kwargs) |
返回一 |
intersect_all(*selects, **kwargs) |
返回一 |
select(*args, **kw) |
创建一个 |
table(name, *columns, **kw) |
产生新的 |
union(*selects, **kwargs) |
返回A |
union_all(*selects, **kwargs) |
返回A |
values(*columns, **kw) |
构建一个 |
返回一 EXCEPT
多个可选择的。
返回的对象是 CompoundSelect
.
返回一 EXCEPT ALL
多个可选择的。
返回的对象是 CompoundSelect
.
构建新的 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)
返回一 INTERSECT
多个可选择的。
返回的对象是 CompoundSelect
.
返回一 INTERSECT ALL
多个可选择的。
返回的对象是 CompoundSelect
.
创建一个 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
.
*entities¶ -- 要从中选择的实体。对于核心用法,这通常是一系列 ColumnElement
和/或 FromClause
将构成结果语句的columns子句的对象。对于那些属于 FromClause
(典型地 Table
或 Alias
对象) FromClause.c
提取集合以形成 ColumnElement
物体。此参数也将接受 TextClause
构造,以及ORM映射类。
产生新的 TableClause
.
返回的对象是的实例 TableClause
表示模式级别的“语法”部分 Table
对象。它可以用来构造轻量级的表构造。
在 1.0.0 版更改: table()
现在可以从平原进口了 sqlalchemy
与任何其他SQL元素一样。
返回A UNION
多个可选择的。
返回的对象是 CompoundSelect
.
类似的 union()
方法可用于所有 FromClause
子类。
返回A UNION ALL
多个可选择的。
返回的对象是 CompoundSelect
.
类似的 union_all()
方法可用于所有 FromClause
子类。
构建一个 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')]
)
这里列出的函数通常作为 FromClause
和 Selectable
元素,例如 alias()
函数通常通过 FromClause.alias()
方法。
Object Name | Description |
---|---|
alias(selectable[, name, flat]) |
返回一 |
cte(selectable[, name, recursive]) |
返回一个新的 |
join(left, right[, onclause, isouter, ...]) |
产生一个 |
lateral(selectable[, name]) |
返回A |
outerjoin(left, right[, onclause, full]) |
返回一 |
tablesample(selectable, sampling[, name, seed]) |
返回A |
返回一 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()
有关详细信息。
返回一个新的 CTE
或公用表表达式实例。
请看 HasCTE.cte()
有关CTE用法的详细信息。
产生一个 Join
对象,给定两个 FromClause
表达。
例如。::
j = join(user_table, address_table,
user_table.c.id == address_table.c.user_id)
stmt = select(user_table).select_from(j)
将沿着以下行发出SQL::
SELECT user.id, user.name FROM user
JOIN address ON user.id = address.user_id
如果有类似的功能 FromClause
对象(例如 Table
)使用 FromClause.join()
方法。
left¶ -- 连接的左侧。
right¶ -- 连接的右侧;这是任何 FromClause
对象,如 Table
对象,也可以是可选的兼容对象,如ORM映射类。
onclause¶ -- 表示联接的ON子句的SQL表达式。如果留在 None
, FromClause.join()
将尝试基于外键关系联接两个表。
isouter¶ -- 如果为true,则呈现左侧外部联接,而不是联接。
full¶ -- 如果为true,则呈现完整的外部联接,而不是联接。…添加的版本:1.1
返回A Lateral
对象。
Lateral
是一个 Alias
子类,表示应用了横向关键字的子查询。
横向子查询的特殊行为是它出现在封闭select的from子句中,但可能与该select的其他from子句相关联。这是子查询的一种特殊情况,只有少量后端支持,目前是更新的PostgreSQL版本。
1.1 新版功能.
参见
横向相关 -使用概述。
返回一 OUTER JOIN
子句元素。
返回的对象是 Join
.
类似功能也可通过 FromClause.outerjoin()
任意方法 FromClause
.
要将连接链结在一起,请使用 FromClause.join()
或 FromClause.outerjoin()
结果的方法 Join
对象。
返回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 新版功能.
这里的类是使用中列出的构造函数生成的 可选择的基础构造函数 和 可选修改器构造函数 .
Object Name | Description |
---|---|
表示表或可选别名(as)。 |
|
表、子查询和其他可选项别名的基类。 |
|
构成 |
|
表示公用表表达式。 |
|
马克A |
|
代表 |
|
表示可以在 |
|
可添加其他元素的select语句的基类。 |
|
声明类以包含CTE支持的mixin。 |
|
代表一个 |
|
表示横向子查询。 |
|
Core构造的最基本类,它具有一些可以表示行的列概念。 |
|
表示标量子查询。 |
|
表示 |
|
将类标记为可选择的。 |
|
select语句的基类。 |
|
表示select的子查询。 |
|
表示最小的“表”构造。 |
|
表示tablesample子句。 |
|
“表值”SQL函数的别名。 |
|
包装一个 |
|
代表一个 |
表示表或可选别名(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
(sqlalchemy.sql.expression.NoInit
, sqlalchemy.sql.expression.FromClause
)
sqlalchemy.sql.expression.AliasedReturnsRows.
description¶sqlalchemy.sql.expression.AliasedReturnsRows.
is_derived_from(fromclause)¶返回 True
如果这样 FromClause
是从给定的 FromClause
.
例如,表的别名是从该表派生的。
sqlalchemy.sql.expression.AliasedReturnsRows.
original¶方言的遗产别名.original.
构成 UNION
, UNION ALL
,以及其他基于SELECT的set操作。
类签名
class sqlalchemy.sql.expression.CompoundSelect
(sqlalchemy.sql.expression.HasCompileState
, sqlalchemy.sql.expression.GenerativeSelect
)
sqlalchemy.sql.expression.CompoundSelect.
bind¶返回 Engine
或 Connection
对此 Executable
是绑定的,如果未找到,则为无。
1.4 版后已移除: 这个 Executable.bind
属性在SQLAlchemy的1.x系列中被认为是遗留的,将在2.0中删除。从SQLAlchemy 2.0开始,绑定的元数据将被删除。(SQLAlchemy 2.0的背景: 迁移到Alchemy )
sqlalchemy.sql.expression.CompoundSelect.
selected_columns¶A ColumnCollection
表示此SELECT语句或类似构造在其结果集中返回的列,而不包括 TextClause
构造。
对于一个 CompoundSelect
, the CompoundSelect.selected_columns
属性返回set操作中的一系列语句中包含的第一个SELECT语句的选定列。
1.4 新版功能.
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
只需返回自我。
表示公用表表达式。
这个 CTE
对象是使用 SelectBase.cte()
方法。不常用的语法也允许使用 HasCTE.cte()
方法存在于 DML 构造,例如 Insert
, Update
和 Delete
. 见 HasCTE.cte()
方法获取有关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
)
sqlalchemy.sql.expression.CTE.
alias(name=None, flat=False)¶此方法是 FromClause.alias()
方法。
马克A ClauseElement
作为支持执行。
Executable
是所有“语句”类型对象的超类,包括 select()
, delete()
, update()
, insert()
, text()
.
类签名
class sqlalchemy.sql.expression.Executable
(sqlalchemy.sql.roles.StatementRole
, sqlalchemy.sql.expression.Generative
)
sqlalchemy.sql.expression.Executable.
bind¶返回 Engine
或 Connection
对此 Executable
是绑定的,如果未找到,则为无。
1.4 版后已移除: 这个 Executable.bind
属性在SQLAlchemy的1.x系列中被认为是遗留的,将在2.0中删除。从SQLAlchemy 2.0开始,绑定的元数据将被删除。(SQLAlchemy 2.0的背景: 迁移到Alchemy )
这是一个遍历,它在本地进行检查,然后在关联对象的“from”子句之间进行检查,直到找到绑定的引擎或连接为止。
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 )
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()
完整的选项列表。
sqlalchemy.sql.expression.Executable.
get_execution_options()¶获取将在执行期间生效的非SQL选项。
1.3 新版功能.
sqlalchemy.sql.expression.Executable.
options(*options)¶将选项应用于此语句。
一般来说,options是可以由SQL编译器解释语句的任何种类的Python对象。这些选项可以由特定方言或特定种类的编译器使用。
最常见的一种选项是ORM级别的选项,它将“急切加载”和其他加载行为应用于ORM查询。然而,从理论上讲,期权可以用于许多其他目的。
有关特定类型语句的特定类型选项的背景信息,请参阅这些选项对象的文档。
在 1.4 版更改: -增加的 Generative.options()
对语句对象进行核心化,以实现统一的Core/ORM查询功能。
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 )
代表 EXISTS
条款。
见 exists()
关于用法的描述。
sqlalchemy.sql.expression.Exists.
__init__(*args, **kwargs)¶构建新的 Exists
对象。
此构造函数被镜像为公共API函数;请参见 sqlalchemy.sql.expression.exists()
完整的用法和参数描述。
sqlalchemy.sql.expression.Exists.
correlate(*fromclause)¶将关联应用于 Exists
.
sqlalchemy.sql.expression.Exists.
correlate_except(*fromclause)¶将关联应用于 Exists
.
sqlalchemy.sql.expression.Exists.
select(whereclause=None, **kwargs)¶返回此选项 Exists
.
例如。::
stmt = exists(some_table.c.id).where(some_table.c.id == 5).select()
这将产生一个类似于:
SELECT EXISTS (SELECT id FROM some_table WHERE some_table = :param) AS anon_1
whereclause¶ -- 调用子句,相当于调用 Select.where()
方法。。已弃用::1.4 Exists.select().whereclause
参数已弃用,将在版本2.0中删除。请利用 Select.where()
方法将WHERE条件添加到SELECT语句。
**kwargs¶ -- 其他关键字参数传递给的旧构造函数 Select
描述在 Select.create_legacy_select()
. .. 已弃用::1.4 Exists.select()
方法将不再接受2.0版中的关键字参数。请使用 Select
构造以应用其他修改。
参见
select()
-允许任意列列表的通用方法。
sqlalchemy.sql.expression.Exists.
select_from(*froms)¶返回一个新的 Exists
构造,将给定表达式应用于 Select.select_from()
包含的select语句的方法。
注解
通常最好建立一个 Select
语句,包括所需的WHERE子句,然后使用 SelectBase.exists()
方法生成 Exists
立刻反对。
sqlalchemy.sql.expression.Exists.
where(clause)¶返回一个新的 exists()
将给定表达式添加到其WHERE子句中,并通过AND(如果有)连接到现有子句。
注解
通常最好建立一个 Select
语句,包括所需的WHERE子句,然后使用 SelectBase.exists()
方法生成 Exists
立刻反对。
表示可以在 FROM
A的子句 SELECT
语句。
最常见的形式 FromClause
是 Table
以及 select()
构造。所有人共同的主要特征 FromClause
对象包括:
一 c
集合,它提供对集合的按名称访问 ColumnElement
物体。
一 primary_key
属性,它是所有这些属性的集合 ColumnElement
指示 primary_key
旗帜。
生成“from”子句的各种派生的方法,包括 FromClause.alias()
, FromClause.join()
, FromClause.select()
.
类签名
class sqlalchemy.sql.expression.FromClause
(sqlalchemy.sql.roles.AnonymizedFromClauseRole
, sqlalchemy.sql.expression.Selectable
)
sqlalchemy.sql.expression.FromClause.
alias(name=None, flat=False)¶返回此的别名 FromClause
.
例如。::
a2 = some_table.alias('a2')
上面的代码创建一个 Alias
对象,可在任何select语句中用作FROM子句。
sqlalchemy.sql.expression.FromClause.
c¶基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 FromClause.c
属性是 FromClause.columns
属性。
sqlalchemy.sql.expression.FromClause.
columns¶基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select(mytable).where(mytable.c.somecolumn == 5)
一 ColumnCollection
对象。
sqlalchemy.sql.expression.FromClause.
description¶对此的简要描述 FromClause
.
主要用于错误消息格式。
sqlalchemy.sql.expression.FromClause.
entity_namespace¶返回用于SQL表达式中基于名称的访问的命名空间。
这是用于解析“filter_by()”类型表达式的命名空间,例如:
stmt.filter_by(address='some address')
它默认为 .c
集合,但是在内部可以使用“entity_namespace”注释重写它,以传递其他结果。
sqlalchemy.sql.expression.FromClause.
exported_columns¶A ColumnCollection
它表示此的“导出”列 Selectable
.
的“导出”列 FromClause
对象与 FromClause.columns
收集。
1.4 新版功能.
sqlalchemy.sql.expression.FromClause.
foreign_keys¶返回 ForeignKey
此FromClause引用的标记对象。
每个人 ForeignKey
是一个 Table
-宽度 ForeignKeyConstraint
。
sqlalchemy.sql.expression.FromClause.
is_derived_from(fromclause)¶返回 True
如果这样 FromClause
是从给定的 FromClause
.
例如,表的别名是从该表派生的。
sqlalchemy.sql.expression.FromClause.
join(right, onclause=None, isouter=False, full=False)¶返回A Join
由此 FromClause
对另一个 FromClause
.
例如。::
from sqlalchemy import join
j = user_table.join(address_table,
user_table.c.id == address_table.c.user_id)
stmt = select(user_table).select_from(j)
将沿着以下行发出SQL::
SELECT user.id, user.name FROM user
JOIN address ON user.id = address.user_id
right¶ -- 连接的右侧;这是任何 FromClause
对象,如 Table
对象,也可以是可选的兼容对象,如ORM映射类。
onclause¶ -- 表示联接的ON子句的SQL表达式。如果留在 None
, FromClause.join()
将尝试基于外键关系联接两个表。
isouter¶ -- 如果为true,则呈现左侧外部联接,而不是联接。
full¶ -- 如果为true,则呈现完整的外部联接,而不是左外部联接。暗示 FromClause.join.isouter
. …添加的版本:1.1
sqlalchemy.sql.expression.FromClause.
outerjoin(right, onclause=None, full=False)¶返回A Join
由此 FromClause
对另一个 FromClause
,并将“Isouter”标志设置为true。
例如。::
from sqlalchemy import outerjoin
j = user_table.outerjoin(address_table,
user_table.c.id == address_table.c.user_id)
以上相当于:
j = user_table.join(
address_table,
user_table.c.id == address_table.c.user_id,
isouter=True)
right¶ -- 连接的右侧;这是任何 FromClause
对象,如 Table
对象,也可以是可选的兼容对象,如ORM映射类。
onclause¶ -- 表示联接的ON子句的SQL表达式。如果留在 None
, FromClause.join()
将尝试基于外键关系联接两个表。
full¶ -- 如果为true,则呈现完整的外部联接,而不是左外部联接。…添加的版本:1.1
sqlalchemy.sql.expression.FromClause.
primary_key¶返回的iterable集合 Column
对象,这些对象构成 _selectable.FromClause
.
对于一个 Table
对象,此集合由 PrimaryKeyConstraint
它本身就是 Column
物体。
sqlalchemy.sql.expression.FromClause.
schema = None¶为此定义“schema”属性 FromClause
.
这是典型的 None
对于大多数对象,除了 Table
,其中它被视为 Table.schema
争论。
sqlalchemy.sql.expression.FromClause.
select(whereclause=None, **kwargs)¶返回此选项 FromClause
.
例如。::
stmt = some_table.select().where(some_table.c.id == 5)
whereclause¶ -- 调用子句,相当于调用 Select.where()
方法。。已弃用::1.4 FromClause.select().whereclause
参数已弃用,将在版本2.0中删除。请利用 Select.where()
方法将WHERE条件添加到SELECT语句。
**kwargs¶ -- 其他关键字参数传递给的旧构造函数 Select
描述在 Select.create_legacy_select()
.
参见
select()
-允许任意列列表的通用方法。
sqlalchemy.sql.expression.FromClause.
table_valued()¶返回一个 TableValuedColumn
此对象的 FromClause
。
A TableValuedColumn
是一种 ColumnElement
它表示表中的完整行。对此构造的支持依赖于后端,并且由PostgreSQL、Oracle和SQL Server等后端以各种形式支持。
例如。::
>>> from sqlalchemy import select, column, func, table
>>> a = table("a", column("id"), column("x"), column("y"))
>>> stmt = select(func.row_to_json(a.table_valued()))
>>> print(stmt)
SELECT row_to_json(a) AS row_to_json_1
FROM a
1.4.0b2 新版功能.
参见
使用SQL函数 - in the SQLAlchemy 1.4/2.0教程
sqlalchemy.sql.expression.FromClause.
tablesample(sampling, name=None, seed=None)¶返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
可添加其他元素的select语句的基类。
这是 Select
和 CompoundSelect
其中可以添加order by、group by等元素,并控制列呈现。比较 TextualSelect
当它子类 SelectBase
它也是一个select构造,表示一个固定的文本字符串,在这个级别上不能更改,只能包装为一个子查询。
类签名
class sqlalchemy.sql.expression.GenerativeSelect
(sqlalchemy.sql.expression.DeprecatedSelectBaseGenerations
, sqlalchemy.sql.expression.SelectBase
)
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 )
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 新版功能.
sqlalchemy.sql.expression.GenerativeSelect.
get_label_style()¶检索当前标签样式。
1.4 新版功能.
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子句的构造。
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
重置它。
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
重置它。
sqlalchemy.sql.expression.GenerativeSelect.
order_by(*clauses)¶返回一个新的可选择的,并应用了ORDER BY条件的给定列表。
例如。::
stmt = select(table).order_by(table.c.id, table.c.name)
*clauses¶ -- 一系列 ColumnElement
用于生成ORDER BY子句的构造。
sqlalchemy.sql.expression.GenerativeSelect.
set_label_style(style)¶返回具有指定标签样式的新可选对象。
有三种“标签样式”可用, LABEL_STYLE_DISAMBIGUATE_ONLY
, LABEL_STYLE_TABLENAME_PLUS_COL
,以及 LABEL_STYLE_NONE
。默认样式为 LABEL_STYLE_TABLENAME_PLUS_COL
。
在现代SQLAlChemy中,通常不需要更改标签样式,因为通过使用 ColumnElement.label()
方法。在过去的版本中, LABEL_STYLE_TABLENAME_PLUS_COL
用于从不同的表、别名或子查询中消除同名列的歧义;较新的 LABEL_STYLE_DISAMBIGUATE_ONLY
现在,标签仅应用于与现有名称冲突的名称,因此此标签的影响最小。
消除歧义的基本原理主要是使所有列表达式都可以从给定的 FromClause.c
创建子查询时的集合。
1.4 新版功能: -The GenerativeSelect.set_label_style()
方法取代了以前的组合 .apply_labels()
, .with_labels()
和 use_labels=True
方法和/或参数。
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中推广的方法。
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方言上。
声明类以包含CTE支持的mixin。
1.1 新版功能.
类签名
class sqlalchemy.sql.expression.HasCTE
(sqlalchemy.sql.roles.HasCTERole
)
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 新版功能.
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()
.
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”。这是一个可选的字符串方言名称,它将此前缀的呈现限制为仅显示该方言。
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”。这是一个可选的字符串方言名称,它将此后缀的呈现限制为仅限于该方言。
代表一个 JOIN
在两者之间构建 FromClause
元素。
的公共构造函数函数 Join
模块级别 join()
函数,以及 FromClause.join()
任意方法 FromClause
(例如 Table
)
类签名
class sqlalchemy.sql.expression.Join
(sqlalchemy.sql.roles.DMLTableRole
, sqlalchemy.sql.expression.FromClause
)
sqlalchemy.sql.expression.Join.
__init__(left, right, onclause=None, isouter=False, full=False)¶构建新的 Join
.
这里通常的入口点是 join()
函数或 FromClause.join()
任意方法 FromClause
对象。
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()
任何可选方法。
sqlalchemy.sql.expression.Join.
bind¶返回与此左侧或右侧关联的绑定引擎 Join
.
1.4 版后已移除: 这个 Executable.bind
属性在SQLAlchemy的1.x系列中被认为是遗留的,将在2.0中删除。从SQLAlchemy 2.0开始,绑定的元数据将被删除。(SQLAlchemy 2.0的背景: 迁移到Alchemy )
sqlalchemy.sql.expression.Join.
description¶sqlalchemy.sql.expression.Join.
is_derived_from(fromclause)¶返回 True
如果这样 FromClause
是从给定的 FromClause
.
例如,表的别名是从该表派生的。
sqlalchemy.sql.expression.Join.
select(whereclause=None, **kwargs)¶例如。::
stmt = table_a.join(table_b, table_a.c.id == table_b.c.a_id)
stmt = stmt.select()
上面将生成一个类似于的SQL字符串:
SELECT table_a.id, table_a.col, table_b.id, table_b.a_id
FROM table_a JOIN table_b ON table_a.id = table_b.a_id
whereclause¶ -- WHERE条件,与调用相同 Select.where()
在结果语句上。。已弃用::1.4 Join.select().whereclause
参数已弃用,将在版本2.0中删除。请利用 Select.where()
方法将WHERE条件添加到SELECT语句。
**kwargs¶ -- 其他关键字参数传递给的旧构造函数 Select
描述在 Select.create_legacy_select()
.
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
只需返回自我。
表示横向子查询。
此对象是由 lateral()
模块级功能以及 FromClause.lateral()
方法适用于所有 FromClause
子类。
虽然横向是SQL标准的一部分,但目前只有更新的PostgreSQL版本才支持这个关键字。
1.1 新版功能.
参见
横向相关 -使用概述。
Core构造的最基本类,它具有一些可以表示行的列概念。
虽然SELECT语句和表是我们在这个类别中考虑的主要内容,但是像INSERT、UPDATE和DELETE这样的DML也可以指定return,这意味着它们可以在cte和其他表单中使用,PostgreSQL还具有返回行的函数。
1.4 新版功能.
类签名
class sqlalchemy.sql.expression.ReturnsRows
(sqlalchemy.sql.roles.ReturnsRowsRole
, sqlalchemy.sql.expression.ClauseElement
)
sqlalchemy.sql.expression.ReturnsRows.
exported_columns¶A ColumnCollection
它表示此的“导出”列 ReturnsRows
.
“导出”列表示 ColumnElement
此SQL构造呈现的表达式。有一些主要变体是FROM子句的“FROM子句列”,例如表、联接或子查询,“SELECTed columns”是SELECT语句的“columns子句”中的列,以及DML语句中的返回列。。
1.4 新版功能.
表示标量子查询。
A ScalarSelect
通过调用 SelectBase.scalar_subquery()
方法。然后,该对象以SQL列表达式的形式参与其他SQL表达式 ColumnElement
层次结构。
类签名
class sqlalchemy.sql.expression.ScalarSelect
(sqlalchemy.sql.roles.InElementRole
, sqlalchemy.sql.expression.Generative
, sqlalchemy.sql.expression.Grouping
)
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映射类)将成为相关集合的一部分。
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映射类)将成为相关异常集合的一部分。
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
只需返回自我。
sqlalchemy.sql.expression.ScalarSelect.
where(crit)¶将WHERE子句应用于此引用的SELECT语句 ScalarSelect
.
表示 SELECT
语句。
这个 Select
对象通常使用 select()
功能。有关详细信息,请参见该函数。
类签名
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
)
sqlalchemy.sql.expression.Select.
add_columns(*columns)¶返回一个新的 select()
将给定的列表达式添加到其columns子句中。
例如。::
my_select = my_select.add_columns(table.c.new_column)
参见文档 Select.with_only_columns()
有关添加/替换 Select
对象。
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 新版功能.
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()
方法。
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 )
sqlalchemy.sql.expression.Select.
as_scalar()¶inherited from the SelectBase.as_scalar()
method of SelectBase
1.4 版后已移除: 这个 SelectBase.as_scalar()
方法已弃用,将在将来的版本中删除。请参考 SelectBase.scalar_subquery()
.
sqlalchemy.sql.expression.Select.
bind¶返回 Engine
或 Connection
对此 Executable
是绑定的,如果未找到,则为无。
1.4 版后已移除: 这个 Executable.bind
属性在SQLAlchemy的1.x系列中被认为是遗留的,将在2.0中删除。从SQLAlchemy 2.0开始,绑定的元数据将被删除。(SQLAlchemy 2.0的背景: 迁移到Alchemy )
sqlalchemy.sql.expression.Select.
c¶inherited from the SelectBase.c
attribute of SelectBase
1.4 版后已移除: 这个 SelectBase.c
和 SelectBase.columns
属性已弃用,将在将来的版本中删除;这些属性隐式创建一个应显式的子查询。请给我打电话 SelectBase.subquery()
首先创建一个子查询,然后包含该属性。要访问此选择对象所选的列,请使用 SelectBase.selected_columns
属性。
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
对象。
sqlalchemy.sql.expression.Select.
column_descriptions¶返回“column descriptions”结构,该结构可以是 plugin-specific .
sqlalchemy.sql.expression.Select.
columns_clause_froms¶返回一组 FromClause
此SELECT语句的COLUMNS子句隐含的对象。
1.4.23 新版功能.
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映射类)将成为相关集合的一部分。
sqlalchemy.sql.expression.Select.
correlate_except(*fromclauses)¶返回一个新的 Select
它将从自相关过程中省略给定的FROM子句。
调用 Select.correlate_except()
关掉 Select
对象对于给定的源元素的“自动相关”默认行为。此处指定的元素将无条件地显示在“发件人”列表中,而所有其他“发件人”元素都将服从正常的自动相关行为。
如果 None
通过, Select
对象将关联其所有源项。
*fromclauses¶ -- 一个或多个列表 FromClause
构造或其他兼容的构造(即ORM映射类)将成为相关异常集合的一部分。
sqlalchemy.sql.expression.Select.
corresponding_column(column, require_embedded=False)¶inherited from the Selectable.corresponding_column()
method of Selectable
给出了一个 ColumnElement
,返回导出的 ColumnElement
对象从 Selectable.exported_columns
这个的集合 Selectable
与原件相对应 ColumnElement
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配。
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 Selectable
. 通常情况下,如果该列仅与该列的导出列共享一个共同的祖先,则该列将匹配 Selectable
.
参见
Selectable.exported_columns
- ColumnCollection
那是用来做手术的。
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()
构造。
columns¶ --
列表 ColumnElement
或 FromClause
将构成结果语句的columns子句的对象。对于那些属于 FromClause
(典型地 Table
或 Alias
对象) FromClause.c
提取集合以形成 ColumnElement
物体。
此参数也将接受 TextClause
构造,以及ORM映射类。
注解
这个 select.columns
参数的方法形式不可用 select()
,例如 FromClause.select()
.
whereclause¶ -- A ClauseElement
将用于构成 WHERE
条款。通常,最好将Where条件添加到现有的 Select
使用方法链接 Select.where()
. …参阅: Select.where()
from_obj¶ -- 列表 ClauseElement
将添加到 FROM
结果语句的子句。这相当于呼叫 Select.select_from()
在现有的 Select
对象。…参阅: Select.select_from()
-明确的从句规范的完整描述。
bind=None¶ -- 一个 Engine
或 Connection
结果所指向的实例 Select
对象将被绑定。这个 Select
否则,对象将自动绑定到 Connectable
实例可以位于其包含的 ClauseElement
成员。
correlate=True¶ -- 表示此 Select
对象应该包含它 FromClause
元素“相关”到封闭 Select
对象。通常,最好在现有的 Select
构建使用 Select.correlate()
. …参阅: Select.correlate()
-相关性的完整描述。
distinct=False¶ -- 什么时候? True
应用A DISTINCT
结果语句的columns子句的限定符。布尔参数也可以是列表达式或列表达式列表-这是一种特殊的调用形式,PostgreSQL方言可以理解它来呈现 DISTINCT ON (<columns>)
语法。 distinct
也可以在现有的 Select
对象通过 Select.distinct()
方法。…参阅: Select.distinct()
group_by¶ -- 一览表 ClauseElement
将构成 GROUP BY
结果选择的子句。通常使用 Select.group_by()
现有的方法 Select
. …参阅: Select.group_by()
having¶ -- 一 ClauseElement
这将包括 HAVING
结果select when的子句 GROUP BY
使用。通常使用 Select.having()
现有的方法 Select
. …参阅: Select.having()
limit=None¶ -- 通常呈现为 LIMIT
结果选择中的表达式。不支持的后端 LIMIT
将尝试提供类似的功能。通常使用 Select.limit()
现有的方法 Select
. …参阅: Select.limit()
offset=None¶ -- 通常呈现为 OFFSET
结果选择中的表达式。不支持的后端 OFFSET
将尝试提供类似的功能。通常使用 Select.offset()
现有的方法 Select
. …参阅: Select.offset()
order_by¶ -- 标量或列表 ClauseElement
将构成 ORDER BY
结果选择的子句。通常使用 Select.order_by()
现有的方法 Select
. …参阅: Select.order_by()
use_labels=False¶ -- 什么时候 True
时,将使用COLUMNS子句中每列的标签生成语句,这将用其父表(或别名)名称限定每列,以便不同表中的列之间不会发生名称冲突。标签的格式为 <tablename>_<column>
。对象的“c”集合 Subquery
针对此创建 Select
对象,以及 Select.selected_columns
集合中的 Select
本身将使用这些名称作为列成员的目标。也可以在现有的 Select
对象使用 Select.set_label_style()
方法。。。另请参阅:: Select.set_label_style()
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()
.
sqlalchemy.sql.expression.Select.
distinct(*expr)¶返回一个新的 select()
构造,它将对其columns子句应用DISTINCT。
*expr¶ -- 可选列表达式。当存在时,PostgreSQL方言将呈现 DISTINCT ON (<expressions>>)
构造。。已弃用::1.4使用 * 其他方言中的expr已被弃用,并将提高 CompileError
在未来的版本中。
sqlalchemy.sql.expression.Select.
except_(other, **kwargs)¶返回SQL EXCEPT
此select()构造的。
sqlalchemy.sql.expression.Select.
except_all(other, **kwargs)¶返回SQL EXCEPT ALL
此select()构造的。
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 )
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()
完整的选项列表。
sqlalchemy.sql.expression.Select.
exists()¶inherited from the SelectBase.exists()
method of SelectBase
返回一 Exists
可选择列作为此表达式的表示形式。
返回的对象是 Exists
.
1.4 新版功能.
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 新版功能.
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 新版功能.
sqlalchemy.sql.expression.Select.
filter(*criteria)¶的同义词 Select.where()
方法。
sqlalchemy.sql.expression.Select.
filter_by(**kwargs)¶将给定的筛选条件作为WHERE子句应用于此select。
sqlalchemy.sql.expression.Select.
from_statement(statement)¶应用此列 Select
会选择另一个语句。
这次行动是 plugin-specific 并将引发不支持的异常,如果 Select
不从启用插件的实体中选择。
语句通常是 text()
或 select()
构造,并应返回与此表示的实体相应的列集 Select
.
参见
从文本和核心语句获取ORM结果 -ORM查询指南中的用法示例
sqlalchemy.sql.expression.Select.
froms¶返回显示的列表 FromClause
元素。
1.4.23 版后已移除: 这个 Select.froms
属性被移动到 Select.get_final_froms()
方法。
sqlalchemy.sql.expression.Select.
get_children(**kwargs)¶返回直接子项 Traversible
其中的要素 Traversible
.
用于访问遍历。
* *kw可能包含更改返回的集合的标志,例如返回一个子集以减少较大的遍历,或者从不同的上下文返回子项(例如模式级集合而不是子句级集合)。
sqlalchemy.sql.expression.Select.
get_execution_options()¶inherited from the Executable.get_execution_options()
method of Executable
获取将在执行期间生效的非SQL选项。
1.3 新版功能.
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
访问器,它已弃用。
sqlalchemy.sql.expression.Select.
get_label_style()¶inherited from the GenerativeSelect.get_label_style()
method of GenerativeSelect
检索当前标签样式。
1.4 新版功能.
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子句的构造。
sqlalchemy.sql.expression.Select.
having(having)¶返回一个新的 select()
将给定表达式添加到其HAVING子句中,并通过AND(如果有)连接到现有子句。
sqlalchemy.sql.expression.Select.
inner_columns¶所有的迭代器 ColumnElement
将呈现到结果SELECT语句的columns子句中的表达式。
此方法是1.4版的遗留方法,并被 Select.exported_columns
收集。
sqlalchemy.sql.expression.Select.
intersect(other, **kwargs)¶返回SQL INTERSECT
此select()构造的。
sqlalchemy.sql.expression.Select.
intersect_all(other, **kwargs)¶返回SQL INTERSECT ALL
此select()构造的。
sqlalchemy.sql.expression.Select.
join(target, onclause=None, isouter=False, full=False)¶针对此创建SQL联接 Select
对象的标准并生成应用,返回新生成的 Select
.
例如。::
stmt = select(user_table).join(address_table, user_table.c.id == address_table.c.user_id)
以上语句生成的SQL类似于::
SELECT user.id, user.name FROM user JOIN address ON user.id = address.user_id
在 1.4 版更改: Select.join()
现在创建一个 Join
对象之间 FromClause
位于现有SELECT的FROM子句中的源,以及给定的目标 FromClause
,然后添加这个 Join
新生成的SELECT语句的FROM子句。这完全是对1.3中的行为进行了修改,它将创建整个 Select
然后将该子查询连接到目标。
这是一个 向后不兼容更改 由于前面的行为基本上是无用的,因此产生了一个未命名的子查询,这在任何情况下都会被大多数数据库拒绝。新的行为是模仿那些非常成功的 Query.join()
方法,以支持 Query
通过使用 Select
对象与 Session
.
有关此更改的说明,请参见 select().join()和outerjoin()将连接条件添加到当前查询,而不是创建子查询 .
target¶ -- 要加入的目标表
onclause¶ -- 连接的ON子句。如果省略,则根据 ForeignKey
如果可以明确确定两个表之间的链接,则会引发错误。
isouter¶ -- 如果为True,则生成外部联接。等同于 Select.outerjoin()
.
full¶ -- 如果为True,则生成完整的外部联接。
参见
显式FROM子句和连接 - in the SQLAlchemy 1.4/2.0教程
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,则生成完整的外部联接。
sqlalchemy.sql.expression.Select.
label(name)¶inherited from the SelectBase.label()
method of SelectBase
返回此可选的“标量”表示形式,嵌入为带有标签的子查询。
sqlalchemy.sql.expression.Select.
lateral(name=None)¶inherited from the SelectBase.lateral()
method of SelectBase
返回此的横向别名 Selectable
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
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
重置它。
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
重置它。
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查询功能。
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子句的构造。
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()将连接条件添加到当前查询,而不是创建子查询 .
sqlalchemy.sql.expression.Select.
outerjoin_from(from_, target, onclause=None, full=False)¶针对此创建SQL LEFT OUTER JOIN Select
对象的标准,并以生成性方式应用,返回新产生的 Select
。
用法与的用法相同 Select.join_from()
。
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”。这是一个可选的字符串方言名称,它将此前缀的呈现限制为仅显示该方言。
sqlalchemy.sql.expression.Select.
reduce_columns(only_synonyms=True)¶返回一个新的 select()
构造具有从columns子句中删除的具有冗余名称且值相等的列。
这里的“冗余”是指两列,其中一列基于外键引用另一列,或者通过语句的WHERE子句中的简单相等比较来引用另一列。此方法的主要目的是自动构造包含所有具有唯一名称的列的SELECT语句,而不需要使用表限定名为 Select.set_label_style()
确实如此。
当根据外键省略列时,引用的列是保留的列。当根据WhereEquivalence省略列时,column s子句中的第一列就是保留的列。
only_synonyms¶ -- 如果为true,则将删除列的操作限制为与等效项同名的操作。否则,将删除与另一列等效的所有列。
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模块可以使用类似的功能。
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 )
sqlalchemy.sql.expression.Select.
scalar_subquery()¶inherited from the SelectBase.scalar_subquery()
method of SelectBase
返回此可选项的“标量”表示形式,可将其用作列表达式。
返回的对象是 ScalarSelect
.
通常,只有一列的SELECT语句可以用作标量表达式。然后,可以在封闭select的where子句或columns子句中使用标量子查询。
注意,标量子查询与使用 SelectBase.subquery()
方法。
sqlalchemy.sql.expression.Select.
select(*arg, **kw)¶inherited from the SelectBase.select()
method of SelectBase
1.4 版后已移除: 这个 SelectBase.select()
方法已弃用,将在将来的版本中删除;此方法隐式创建应显式的子查询。请给我打电话 SelectBase.subquery()
首先创建一个子查询,然后可以选择该子查询。
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)
sqlalchemy.sql.expression.Select.
selected_columns¶A ColumnCollection
表示此SELECT语句或类似构造在其结果集中返回的列,而不包括 TextClause
构造。
此集合与 FromClause.columns
A的集合 FromClause
因为此集合中的列不能直接嵌套在另一个select语句中;必须首先应用子查询,该查询提供了SQL所需的括号。
对于 select()
构造时,此处的集合就是将在“select”语句内呈现的集合,而 ColumnElement
对象按给定方式直接存在,例如::
col1 = column('q', Integer)
col2 = column('p', Integer)
stmt = select(col1, col2)
上图, stmt.selected_columns
将是一个集合,该集合包含 col1
和 col2
直接访问对象。对于反对 Table
或其他 FromClause
,集合将使用 ColumnElement
中的对象 FromClause.c
From元素的集合。
注解
这个 Select.selected_columns
集合不包括在COLUMNS子句中使用 text()
构造;这些将从集合中静默省略。中使用纯文本列表达式 Select
构造,请使用 literal_column()
构造。
1.4 新版功能.
sqlalchemy.sql.expression.Select.
self_group(against=None)¶根据返回“grouping”构造 ClauseElement
规范。
这将生成一个可以嵌入到表达式中的元素。请注意,在构造表达式时,此方法是根据需要自动调用的,不需要显式使用。
sqlalchemy.sql.expression.Select.
set_label_style(style)¶inherited from the GenerativeSelect.set_label_style()
method of GenerativeSelect
返回具有指定标签样式的新可选对象。
有三种“标签样式”可用, LABEL_STYLE_DISAMBIGUATE_ONLY
, LABEL_STYLE_TABLENAME_PLUS_COL
,以及 LABEL_STYLE_NONE
。默认样式为 LABEL_STYLE_TABLENAME_PLUS_COL
。
在现代SQLAlChemy中,通常不需要更改标签样式,因为通过使用 ColumnElement.label()
方法。在过去的版本中, LABEL_STYLE_TABLENAME_PLUS_COL
用于从不同的表、别名或子查询中消除同名列的歧义;较新的 LABEL_STYLE_DISAMBIGUATE_ONLY
现在,标签仅应用于与现有名称冲突的名称,因此此标签的影响最小。
消除歧义的基本原理主要是使所有列表达式都可以从给定的 FromClause.c
创建子查询时的集合。
1.4 新版功能: -The GenerativeSelect.set_label_style()
方法取代了以前的组合 .apply_labels()
, .with_labels()
和 use_labels=True
方法和/或参数。
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中推广的方法。
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 新版功能.
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”。这是一个可选的字符串方言名称,它将此后缀的呈现限制为仅限于该方言。
sqlalchemy.sql.expression.Select.
union(other, **kwargs)¶返回SQL UNION
此select()构造的。
sqlalchemy.sql.expression.Select.
union_all(other, **kwargs)¶返回SQL UNION ALL
此select()构造的。
sqlalchemy.sql.expression.Select.
where(*whereclause)¶返回一个新的 select()
将给定表达式添加到其WHERE子句中,并通过AND(如果有)连接到现有子句。
sqlalchemy.sql.expression.Select.
whereclause¶为此返回已完成的WHERE子句 Select
语句。
这将把WHERE条件的当前集合组合成一个 BooleanClauseList
构造。
1.4 新版功能.
sqlalchemy.sql.expression.Select.
with_for_update(nowait=False, read=False, of=None, skip_locked=False, key_share=False)¶inherited from the GenerativeSelect.with_for_update()
method of GenerativeSelect
指定一个 FOR UPDATE
此条款 GenerativeSelect
.
例如。::
stmt = select(table).with_for_update(nowait=True)
在PostgreSQL或Oracle这样的数据库上,上面的语句将呈现如下:
SELECT table.a, table.b FROM table FOR UPDATE NOWAIT
在其他后端, nowait
选项被忽略,将生成::
SELECT table.a, table.b FROM table FOR UPDATE
当不带参数调用时,该语句将以后缀呈现 FOR UPDATE
. 然后可以提供其他参数,以允许常见的特定于数据库的变量。
nowait¶ -- 布尔值;将呈现 FOR UPDATE NOWAIT
关于Oracle和PostgreSQL方言。
read¶ -- 布尔值;将呈现 LOCK IN SHARE MODE
关于MySQL, FOR SHARE
在PostgreSQL上。在PostgreSQL上,当与 nowait
将渲染 FOR SHARE NOWAIT
.
of¶ -- SQL表达式或SQL表达式元素列表(通常 Column
对象或兼容表达式),它将呈现为 FOR UPDATE OF
子句;由PostgreSQL和Oracle支持。可以呈现为表或列,具体取决于后端。
skip_locked¶ -- 布尔值,将呈现 FOR UPDATE SKIP LOCKED
关于Oracle和PostgreSQL方言或 FOR SHARE SKIP LOCKED
如果 read=True
也指定了。
key_share¶ -- 布尔值,将呈现 FOR NO KEY UPDATE
,或者如果与 read=True
将渲染 FOR KEY SHARE
在PostgreSQL方言上。
sqlalchemy.sql.expression.Select.
with_hint(selectable, text, dialect_name='*')¶inherited from the HasHints.with_hint()
method of HasHints
为给定的可选对象添加索引或其他执行上下文提示 Select
或其他可选对象。
提示的文本呈现在正在使用的数据库后端的适当位置,相对于给定的 Table
或 Alias
作为传递 selectable
争论。方言实现通常使用带有标记的python字符串替换语法 %(name)s
呈现表或别名的名称。例如,使用Oracle时,以下内容:
select(mytable).\
with_hint(mytable, "index(%(name)s ix_mytable)")
将SQL呈现为:
select /*+ index(mytable ix_mytable) */ ... from mytable
这个 dialect_name
选项将把特定提示的呈现限制到特定的后端。例如,要同时为Oracle和Sybase添加提示:
select(mytable).\
with_hint(mytable, "index(%(name)s ix_mytable)", 'oracle').\
with_hint(mytable, "WITH INDEX ix_mytable", 'sybase')
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
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 新版功能.
将类标记为可选择的。
sqlalchemy.sql.expression.Selectable.
corresponding_column(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
对象从 Selectable.exported_columns
这个的集合 Selectable
与原件相对应 ColumnElement
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配。
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 Selectable
. 通常情况下,如果该列仅与该列的导出列共享一个共同的祖先,则该列将匹配 Selectable
.
参见
Selectable.exported_columns
- ColumnCollection
那是用来做手术的。
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 新版功能.
sqlalchemy.sql.expression.Selectable.
lateral(name=None)¶返回此的横向别名 Selectable
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
sqlalchemy.sql.expression.Selectable.
replace_selectable(old, alias)¶替换所有出现的 FromClause
“旧”与给定 Alias
对象,返回此 FromClause
.
1.4 版后已移除: 这个 Selectable.replace_selectable()
方法已弃用,将在将来的版本中删除。通过sqlacalchemy.sql.visitors模块可以使用类似的功能。
select语句的基类。
这包括 Select
, CompoundSelect
和 TextualSelect
.
类签名
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
)
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 新版功能.
sqlalchemy.sql.expression.SelectBase.
alias(name=None, flat=False)¶针对此返回命名子查询 SelectBase
.
对于一个 SelectBase
(与 FromClause
,这将返回 Subquery
对象的行为与 Alias
与一起使用的对象 FromClause
.
在 1.4 版更改: 这个 SelectBase.alias()
方法现在是 SelectBase.subquery()
方法。
sqlalchemy.sql.expression.SelectBase.
as_scalar()¶1.4 版后已移除: 这个 SelectBase.as_scalar()
方法已弃用,将在将来的版本中删除。请参考 SelectBase.scalar_subquery()
.
sqlalchemy.sql.expression.SelectBase.
bind¶inherited from the Executable.bind
attribute of Executable
返回 Engine
或 Connection
对此 Executable
是绑定的,如果未找到,则为无。
1.4 版后已移除: 这个 Executable.bind
属性在SQLAlchemy的1.x系列中被认为是遗留的,将在2.0中删除。从SQLAlchemy 2.0开始,绑定的元数据将被删除。(SQLAlchemy 2.0的背景: 迁移到Alchemy )
这是一个遍历,它在本地进行检查,然后在关联对象的“from”子句之间进行检查,直到找到绑定的引擎或连接为止。
sqlalchemy.sql.expression.SelectBase.
c¶1.4 版后已移除: 这个 SelectBase.c
和 SelectBase.columns
属性已弃用,将在将来的版本中删除;这些属性隐式创建一个应显式的子查询。请给我打电话 SelectBase.subquery()
首先创建一个子查询,然后包含该属性。要访问此选择对象所选的列,请使用 SelectBase.selected_columns
属性。
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
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配。
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 Selectable
. 通常情况下,如果该列仅与该列的导出列共享一个共同的祖先,则该列将匹配 Selectable
.
参见
Selectable.exported_columns
- ColumnCollection
那是用来做手术的。
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()
.
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 )
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()
完整的选项列表。
sqlalchemy.sql.expression.SelectBase.
exists()¶返回一 Exists
可选择列作为此表达式的表示形式。
返回的对象是 Exists
.
1.4 新版功能.
sqlalchemy.sql.expression.SelectBase.
exported_columns¶A ColumnCollection
的“导出”列的 Selectable
,不包括 TextClause
构造。
的“导出”列 SelectBase
对象与 SelectBase.selected_columns
收集。
1.4 新版功能.
sqlalchemy.sql.expression.SelectBase.
get_execution_options()¶inherited from the Executable.get_execution_options()
method of Executable
获取将在执行期间生效的非SQL选项。
1.3 新版功能.
sqlalchemy.sql.expression.SelectBase.
label(name)¶返回此可选的“标量”表示形式,嵌入为带有标签的子查询。
sqlalchemy.sql.expression.SelectBase.
lateral(name=None)¶返回此的横向别名 Selectable
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
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查询功能。
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模块可以使用类似的功能。
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 )
sqlalchemy.sql.expression.SelectBase.
scalar_subquery()¶返回此可选项的“标量”表示形式,可将其用作列表达式。
返回的对象是 ScalarSelect
.
通常,只有一列的SELECT语句可以用作标量表达式。然后,可以在封闭select的where子句或columns子句中使用标量子查询。
注意,标量子查询与使用 SelectBase.subquery()
方法。
sqlalchemy.sql.expression.SelectBase.
select(*arg, **kw)¶1.4 版后已移除: 这个 SelectBase.select()
方法已弃用,将在将来的版本中删除;此方法隐式创建应显式的子查询。请给我打电话 SelectBase.subquery()
首先创建一个子查询,然后可以选择该子查询。
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 新版功能.
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 新版功能.
表示select的子查询。
A Subquery
通过调用 SelectBase.subquery()
方法,或为了方便 SelectBase.alias()
方法,任何 SelectBase
子类,包括 Select
, CompoundSelect
和 TextualSelect
.正如在FROM子句中呈现的那样,它表示括号内select语句的主体,后跟通常定义所有“alias”对象的“as<somename>”。
这个 Subquery
对象与 Alias
对象和可以以等效的方式使用。两者之间的区别 Alias
和 Subquery
那是 Alias
始终包含 FromClause
反对,鉴于 Subquery
始终包含 SelectBase
对象。
1.4 新版功能: 这个 Subquery
添加了类,该类现在用于提供select语句的别名版本。
sqlalchemy.sql.expression.Subquery.
as_scalar()¶1.4 版后已移除: 这个 Subquery.as_scalar()
方法,以前是 Alias.as_scalar()
在1.4版之前,已弃用,将在将来的版本中删除;请使用 Select.scalar_subquery()
方法 select()
在构造子查询对象之前构造,或使用ORM使用 Query.scalar_subquery()
方法。
表示最小的“表”构造。
这是一个轻量级表对象,它只有一个名称,一组列,这些列通常由 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
)
sqlalchemy.sql.expression.TableClause.
__init__(name, *columns, **kw)¶构建新的 TableClause
对象。
此构造函数被镜像为公共API函数;请参见 sqlalchemy.sql.expression.table()
完整的用法和参数描述。
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子句。
sqlalchemy.sql.expression.TableClause.
c¶inherited from the FromClause.c
attribute of FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 FromClause.c
属性是 FromClause.columns
属性。
sqlalchemy.sql.expression.TableClause.
columns¶inherited from the FromClause.columns
attribute of FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select(mytable).where(mytable.c.somecolumn == 5)
一 ColumnCollection
对象。
sqlalchemy.sql.expression.TableClause.
compare(other, **kw)¶inherited from the ClauseElement.compare()
method of ClauseElement
比较一下 ClauseElement
到给定的 ClauseElement
.
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类消耗的参数 compare()
方法和可用于修改比较标准(请参见 ColumnElement
)
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¶ -- 安 Engine
或 Connection
从哪一个 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
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
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配。
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 Selectable
. 通常情况下,如果该列仅与该列的导出列共享一个共同的祖先,则该列将匹配 Selectable
.
参见
Selectable.exported_columns
- ColumnCollection
那是用来做手术的。
sqlalchemy.sql.expression.TableClause.
delete(whereclause=None, **kwargs)¶生成一个 delete()
在此基础上构建 TableClause
.
例如。::
table.delete().where(table.c.id==7)
见 delete()
获取参数和用法信息。
sqlalchemy.sql.expression.TableClause.
description¶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”注释重写它,以传递其他结果。
sqlalchemy.sql.expression.TableClause.
exported_columns¶inherited from the FromClause.exported_columns
attribute of FromClause
A ColumnCollection
它表示此的“导出”列 Selectable
.
的“导出”列 FromClause
对象与 FromClause.columns
收集。
1.4 新版功能.
sqlalchemy.sql.expression.TableClause.
foreign_keys¶inherited from the FromClause.foreign_keys
attribute of FromClause
返回 ForeignKey
此FromClause引用的标记对象。
每个人 ForeignKey
是一个 Table
-宽度 ForeignKeyConstraint
。
sqlalchemy.sql.expression.TableClause.
get_children(omit_attrs=(), **kw)¶inherited from the Traversible.get_children()
method of Traversible
返回直接子项 Traversible
其中的要素 Traversible
.
用于访问遍历。
* *kw可能包含更改返回的集合的标志,例如返回一个子集以减少较大的遍历,或者从不同的上下文返回子项(例如模式级集合而不是子句级集合)。
sqlalchemy.sql.expression.TableClause.
implicit_returning = False¶TableClause
不支持主键或列级默认值,因此隐式返回不适用。
sqlalchemy.sql.expression.TableClause.
insert(values=None, inline=False, **kwargs)¶生成 insert()
在此基础上构建 TableClause
.
例如。::
table.insert().values(name='foo')
见 insert()
获取参数和用法信息。
sqlalchemy.sql.expression.TableClause.
is_derived_from(fromclause)¶inherited from the FromClause.is_derived_from()
method of FromClause
返回 True
如果这样 FromClause
是从给定的 FromClause
.
例如,表的别名是从该表派生的。
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表达式。如果留在 None
, FromClause.join()
将尝试基于外键关系联接两个表。
isouter¶ -- 如果为true,则呈现左侧外部联接,而不是联接。
full¶ -- 如果为true,则呈现完整的外部联接,而不是左外部联接。暗示 FromClause.join.isouter
. …添加的版本:1.1
sqlalchemy.sql.expression.TableClause.
lateral(name=None)¶inherited from the Selectable.lateral()
method of Selectable
返回此的横向别名 Selectable
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
只读@属性,只计算一次。
sqlalchemy.sql.expression.TableClause.
classmethod memoized_instancemethod(fn)¶inherited from the HasMemoized.memoized_instancemethod()
method of HasMemoized
装饰一个方法记下它的返回值。
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表达式。如果留在 None
, FromClause.join()
将尝试基于外键关系联接两个表。
full¶ -- 如果为true,则呈现完整的外部联接,而不是左外部联接。…添加的版本:1.1
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}
sqlalchemy.sql.expression.TableClause.
primary_key¶inherited from the FromClause.primary_key
attribute of FromClause
返回的iterable集合 Column
对象,这些对象构成 _selectable.FromClause
.
对于一个 Table
对象,此集合由 PrimaryKeyConstraint
它本身就是 Column
物体。
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模块可以使用类似的功能。
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)
whereclause¶ -- 调用子句,相当于调用 Select.where()
方法。。已弃用::1.4 FromClause.select().whereclause
参数已弃用,将在版本2.0中删除。请利用 Select.where()
方法将WHERE条件添加到SELECT语句。
**kwargs¶ -- 其他关键字参数传递给的旧构造函数 Select
描述在 Select.create_legacy_select()
.
参见
select()
-允许任意列列表的通用方法。
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
只需返回自我。
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 新版功能.
参见
使用SQL函数 - in the SQLAlchemy 1.4/2.0教程
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()
-使用指南和参数
sqlalchemy.sql.expression.TableClause.
unique_params(*optionaldict, **kwargs)¶inherited from the Immutable.unique_params()
method of Immutable
返回副本 bindparam()
元素被替换。
功能与 ClauseElement.params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。
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()
获取参数和用法信息。
表示tablesample子句。
此对象是由 tablesample()
模块级功能以及 FromClause.tablesample()
方法适用于所有 FromClause
子类。
1.1 新版功能.
“表值”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 新版功能.
参见
表值函数 - in the SQLAlchemy 1.4/2.0教程
sqlalchemy.sql.expression.TableValuedAlias.
alias(name=None)¶返回此文件的新别名 TableValuedAlias
。
这将创建一个DISTINCT FROM对象,该对象在SQL语句中使用时将有别于原始对象。
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
sqlalchemy.sql.expression.TableValuedAlias.
lateral(name=None)¶返回一个新的 TableValuedAlias
设置了横向标志,以便它呈现为横向。
参见
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)
包装一个 TextClause
在一个 SelectBase
接口。
这允许 TextClause
要获得的对象 .c
收集和其他类似功能,例如 FromClause.alias()
, SelectBase.cte()
等。
这个 TextualSelect
构造是通过 TextClause.columns()
方法-有关详细信息,请参见该方法。
在 1.4 版更改: 这个 TextualSelect
类已从重命名 TextAsFrom
,以便更正确地适应它作为面向选择的对象而不是FROM子句的角色。
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 新版功能.
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()
方法。
sqlalchemy.sql.expression.TextualSelect.
as_scalar()¶inherited from the SelectBase.as_scalar()
method of SelectBase
1.4 版后已移除: 这个 SelectBase.as_scalar()
方法已弃用,将在将来的版本中删除。请参考 SelectBase.scalar_subquery()
.
sqlalchemy.sql.expression.TextualSelect.
bind¶inherited from the Executable.bind
attribute of Executable
返回 Engine
或 Connection
对此 Executable
是绑定的,如果未找到,则为无。
1.4 版后已移除: 这个 Executable.bind
属性在SQLAlchemy的1.x系列中被认为是遗留的,将在2.0中删除。从SQLAlchemy 2.0开始,绑定的元数据将被删除。(SQLAlchemy 2.0的背景: 迁移到Alchemy )
这是一个遍历,它在本地进行检查,然后在关联对象的“from”子句之间进行检查,直到找到绑定的引擎或连接为止。
sqlalchemy.sql.expression.TextualSelect.
c¶inherited from the SelectBase.c
attribute of SelectBase
1.4 版后已移除: 这个 SelectBase.c
和 SelectBase.columns
属性已弃用,将在将来的版本中删除;这些属性隐式创建一个应显式的子查询。请给我打电话 SelectBase.subquery()
首先创建一个子查询,然后包含该属性。要访问此选择对象所选的列,请使用 SelectBase.selected_columns
属性。
sqlalchemy.sql.expression.TextualSelect.
compare(other, **kw)¶inherited from the ClauseElement.compare()
method of ClauseElement
比较一下 ClauseElement
到给定的 ClauseElement
.
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类消耗的参数 compare()
方法和可用于修改比较标准(请参见 ColumnElement
)
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¶ -- 安 Engine
或 Connection
从哪一个 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
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
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配。
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 Selectable
. 通常情况下,如果该列仅与该列的导出列共享一个共同的祖先,则该列将匹配 Selectable
.
参见
Selectable.exported_columns
- ColumnCollection
那是用来做手术的。
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()
.
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 )
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()
完整的选项列表。
sqlalchemy.sql.expression.TextualSelect.
exists()¶inherited from the SelectBase.exists()
method of SelectBase
返回一 Exists
可选择列作为此表达式的表示形式。
返回的对象是 Exists
.
1.4 新版功能.
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 新版功能.
sqlalchemy.sql.expression.TextualSelect.
get_children(omit_attrs=(), **kw)¶inherited from the Traversible.get_children()
method of Traversible
返回直接子项 Traversible
其中的要素 Traversible
.
用于访问遍历。
* *kw可能包含更改返回的集合的标志,例如返回一个子集以减少较大的遍历,或者从不同的上下文返回子项(例如模式级集合而不是子句级集合)。
sqlalchemy.sql.expression.TextualSelect.
get_execution_options()¶inherited from the Executable.get_execution_options()
method of Executable
获取将在执行期间生效的非SQL选项。
1.3 新版功能.
sqlalchemy.sql.expression.TextualSelect.
label(name)¶inherited from the SelectBase.label()
method of SelectBase
返回此可选的“标量”表示形式,嵌入为带有标签的子查询。
sqlalchemy.sql.expression.TextualSelect.
lateral(name=None)¶inherited from the SelectBase.lateral()
method of SelectBase
返回此的横向别名 Selectable
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
只读@属性,只计算一次。
sqlalchemy.sql.expression.TextualSelect.
classmethod memoized_instancemethod(fn)¶inherited from the HasMemoized.memoized_instancemethod()
method of HasMemoized
装饰一个方法记下它的返回值。
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查询功能。
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}
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模块可以使用类似的功能。
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 )
sqlalchemy.sql.expression.TextualSelect.
scalar_subquery()¶inherited from the SelectBase.scalar_subquery()
method of SelectBase
返回此可选项的“标量”表示形式,可将其用作列表达式。
返回的对象是 ScalarSelect
.
通常,只有一列的SELECT语句可以用作标量表达式。然后,可以在封闭select的where子句或columns子句中使用标量子查询。
注意,标量子查询与使用 SelectBase.subquery()
方法。
sqlalchemy.sql.expression.TextualSelect.
select(*arg, **kw)¶inherited from the SelectBase.select()
method of SelectBase
1.4 版后已移除: 这个 SelectBase.select()
方法已弃用,将在将来的版本中删除;此方法隐式创建应显式的子查询。请给我打电话 SelectBase.subquery()
首先创建一个子查询,然后可以选择该子查询。
sqlalchemy.sql.expression.TextualSelect.
selected_columns¶A ColumnCollection
表示此SELECT语句或类似构造在其结果集中返回的列,而不包括 TextClause
构造。
此集合与 FromClause.columns
A的集合 FromClause
因为此集合中的列不能直接嵌套在另一个select语句中;必须首先应用子查询,该查询提供了SQL所需的括号。
对于一个 TextualSelect
构造,集合包含 ColumnElement
传递给构造函数的对象,通常通过 TextClause.columns()
方法。
1.4 新版功能.
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
只需返回自我。
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 新版功能.
sqlalchemy.sql.expression.TextualSelect.
unique_params(*optionaldict, **kwargs)¶inherited from the ClauseElement.unique_params()
method of ClauseElement
返回副本 bindparam()
元素被替换。
功能与 ClauseElement.params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。
代表一个 VALUES
构造,它可以用作语句中的FROM元素。
1.4 新版功能.
类签名
class sqlalchemy.sql.expression.Values
(sqlalchemy.sql.expression.Generative
, sqlalchemy.sql.expression.FromClause
)
sqlalchemy.sql.expression.Values.
__init__(*columns, **kw)¶构建新的 Values
对象。
此构造函数被镜像为公共API函数;请参见 sqlalchemy.sql.expression.values()
完整的用法和参数描述。
sqlalchemy.sql.expression.Values.
alias(name, **kw)¶返回一个新的 Values
构造一个具有给定名称的副本。
此方法是 FromClause.alias()
方法。
sqlalchemy.sql.expression.Values.
data(values)¶返回一个新的 Values
构造,将给定的数据添加到数据列表中。
例如。::
my_values = my_values.data([(1, 'value 1'), (2, 'value2')])
sqlalchemy.sql.expression.Values.
lateral(name=None)¶返回一个新的 Values
设置侧旗,使其渲染为侧向。
参见
与一起使用的常量 GenerativeSelect.set_label_style()
方法。
Object Name | Description |
---|---|
默认标签样式,指的是 |
|
标签样式,指示在生成SELECT语句的COLUMNS子句时,名称与现有名称冲突的列应该使用半匿名标签进行标记。 |
|
指示没有自动标签的标签样式应应用于SELECT语句的COLUMNS子句。 |
|
指示所有列的标签样式应标记为 |
标签样式,指示在生成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 新版功能.
指示没有自动标签的标签样式应应用于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 新版功能.
指示所有列的标签样式应标记为 <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 新版功能.
默认标签样式,指的是 LABEL_STYLE_DISAMBIGUATE_ONLY
。
1.4 新版功能.
flambé! the dragon and The Alchemist image designs created and generously donated by Rotem Yaari.
Created using Sphinx 4.2.0.