术语“可选”是指可以从中选择行的任何对象;在SQLAlchemy中,这些对象从 FromClause
它们的特点是 FromClause.c
属性,它是FROM子句中包含的所有列的命名空间(这些元素本身 ColumnElement
子类)。
sqlalchemy.sql.expression.
alias
(selectable, name=None, flat=False)¶返回一 Alias
对象。
安 Alias
表示任何 FromClause
在SQL中分配了备用名称,通常使用 AS
生成时的子句,例如 SELECT * FROM table AS aliasname
.
类似功能可通过 alias()
方法适用于所有 FromClause
子类。
当一个 Alias
创建自 Table
对象,这具有将表呈现为 tablename AS aliasname
在select语句中。
为了 select()
对象,其效果是创建一个命名的子查询,即 (select ...) AS aliasname
.
这个 name
参数是可选的,并提供在呈现的SQL中使用的名称。如果为空,将在编译时确定地生成一个"匿名"名称。确定性意味着该名称对于同一语句中使用的其他构造是唯一的,并且对于同一语句对象的每个连续编译也将是相同的名称。
selectable¶ -- 任何 FromClause
子类,如表、select语句等。
name¶ -- 要指定为别名的字符串名称。如果 None
,将在编译时确定地生成名称。
flat¶ -- 如果给定的可选对象是 Join
-见 Join.alias()
详情。…添加的版本:0.9.0
sqlalchemy.sql.expression.
except_
(*selects, **kwargs)¶返回一 EXCEPT
多个可选择的。
返回的对象是 CompoundSelect
.
sqlalchemy.sql.expression.
except_all
(*selects, **kwargs)¶返回一 EXCEPT ALL
多个可选择的。
返回的对象是 CompoundSelect
.
sqlalchemy.sql.expression.
exists
(*args, **kwargs)¶构建新的 Exists
反对现有的 Select
对象。
调用样式的形式如下:
# use on an existing select()
s = select([table.c.col1]).where(table.c.col2==5)
s = exists(s)
# construct a select() at once
exists(['*'], **select_arguments).where(criterion)
# columns argument is optional, generates "EXISTS (SELECT *)"
# by default.
exists().where(table.c.col2==5)
sqlalchemy.sql.expression.
intersect
(*selects, **kwargs)¶返回一 INTERSECT
多个可选择的。
返回的对象是 CompoundSelect
.
sqlalchemy.sql.expression.
intersect_all
(*selects, **kwargs)¶返回一 INTERSECT ALL
多个可选择的。
返回的对象是 CompoundSelect
.
sqlalchemy.sql.expression.
join
(left, right, onclause=None, isouter=False, full=False)¶产生一个 Join
对象,给定两个 FromClause
表达。
例如。::
j = join(user_table, address_table,
user_table.c.id == address_table.c.user_id)
stmt = select([user_table]).select_from(j)
将沿着以下行发出SQL::
SELECT user.id, user.name FROM user
JOIN address ON user.id = address.user_id
如果有类似的功能 FromClause
对象(例如 Table
)使用 FromClause.join()
方法。
left¶ -- 连接的左侧。
right¶ -- 连接的右侧;这是任何 FromClause
对象,如 Table
对象,也可以是可选的兼容对象,如ORM映射类。
onclause¶ -- 表示联接的ON子句的SQL表达式。如果留在 None
, FromClause.join()
将尝试基于外键关系联接两个表。
isouter¶ -- 如果为true,则呈现左侧外部联接,而不是联接。
full¶ -- 如果为true,则呈现完整的外部联接,而不是联接。…添加的版本:1.1
sqlalchemy.sql.expression.
lateral
(selectable, name=None)¶返回A Lateral
对象。
Lateral
是一个 Alias
子类,表示应用了横向关键字的子查询。
横向子查询的特殊行为是它出现在封闭select的from子句中,但可能与该select的其他from子句相关联。这是子查询的一种特殊情况,只有少量后端支持,目前是更新的PostgreSQL版本。
1.1 新版功能.
参见
横向相关 -使用概述。
sqlalchemy.sql.expression.
outerjoin
(left, right, onclause=None, full=False)¶返回一 OUTER JOIN
子句元素。
返回的对象是 Join
.
类似功能也可通过 outerjoin()
任意方法 FromClause
.
要将连接链结在一起,请使用 FromClause.join()
或 FromClause.outerjoin()
结果的方法 Join
对象。
sqlalchemy.sql.expression.
select
(columns=None, whereclause=None, from_obj=None, distinct=False, having=None, correlate=True, prefixes=None, suffixes=None, **kwargs)¶构建新的 Select
.
类似功能也可通过 FromClause.select()
任意方法 FromClause
.
接受的所有参数 ClauseElement
参数还接受字符串参数,这些参数将根据需要转换为 text()
或 literal_column()
构造。
columns¶ -- 列表 ColumnElement
或 FromClause
将构成结果语句的columns子句的对象。对于那些属于 FromClause
(典型地 Table
或 Alias
对象) FromClause.c
提取集合以形成 ColumnElement
对象。此参数也将接受 Text
构造,以及ORM映射类。…注:: select.columns
参数的方法形式不可用 select()
,例如 FromClause.select()
. …参阅: Select.column()
Select.with_only_columns()
whereclause¶ -- A ClauseElement
将用于构成 WHERE
条款。通常,最好将Where条件添加到现有的 Select
使用方法链接 Select.where()
. …参阅: Select.where()
from_obj¶ -- 列表 ClauseElement
将添加到 FROM
结果语句的子句。这相当于调用 Select.select_from()
在现有的 Select
对象。…参阅: Select.select_from()
-明确的从句规范的完整描述。
autocommit¶ -- 旧自动提交参数。…已弃用::0.6 select.autocommit
参数已弃用,将在将来的版本中删除。请参阅 Connection.execution_options.autocommit
参数和 Executable.execution_options()
方法以影响语句的自动提交行为。
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
对象通过 distinct()
方法。…参阅: Select.distinct()
for_update=False¶ -- 什么时候? True
应用 FOR UPDATE
到结果语句的结尾。 for_update
接受由特定后端解释的各种字符串值,包括: * "read"
- on MySQL, translates to LOCK IN SHARE MODE
; on PostgreSQL, translates to FOR SHARE
. * "nowait"
-在PostgreSQL和Oracle上,转换为 FOR UPDATE NOWAIT
. * "read_nowait"
-在PostgreSQL上,转换为 FOR SHARE NOWAIT
. …参阅: Select.with_for_update()
-改进了用于指定 FOR UPDATE
条款。
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
,该语句将使用column s子句中每列的标签生成,该标签用父表(或别名)的名称限定每列,这样不同表中的列之间就不会发生名称冲突。标签的格式为<tablename>列>。结果的“c”集合 Select
对象也将使用这些名称作为列成员的目标。也可以在现有的 Select
对象使用 Select.apply_labels()
方法。…参阅: Select.apply_labels()
sqlalchemy.sql.expression.
subquery
(alias, *args, **kwargs)¶别名
* ARGS, * *克沃斯
所有其他参数都传递到
select()
功能。
sqlalchemy.sql.expression.
table
(name, *columns)¶产生新的 TableClause
.
返回的对象是的实例 TableClause
表示模式级别的“语法”部分 Table
对象。它可以用来构造轻量级的表构造。
在 1.0.0 版更改: expression.table()
现在可以从平原进口了 sqlalchemy
与任何其他SQL元素一样。
name¶ -- 表的名称。
columns¶ -- 收藏 expression.column()
构造。
sqlalchemy.sql.expression.
tablesample
(selectable, sampling, name=None, seed=None)¶返回A TableSample
对象。
TableSample
是一个 Alias
表示应用了tablesample子句的表的子类。 tablesample()
也可以从 FromClause
类通过 FromClause.tablesample()
方法。
tablesample子句允许从表中随机选择大约百分比的行。它支持多种采样方法,最常见的是伯努利和系统。
例如。::
from sqlalchemy import func
selectable = people.tablesample(
func.bernoulli(1),
name='alias',
seed=func.random())
stmt = select([selectable.c.people_id])
假设 people
用柱 people_id
,上面的语句将呈现为:
SELECT alias.people_id FROM
people AS alias TABLESAMPLE bernoulli(:bernoulli_1)
REPEATABLE (random())
1.1 新版功能.
sampling¶ -- 一 float
0到100之间的百分比或 functions.Function
.
name¶ -- 可选别名
seed¶ -- 任何实值SQL表达式。如有规定,还应提供可重复的子条款。
sqlalchemy.sql.expression.
union
(*selects, **kwargs)¶返回A UNION
多个可选择的。
返回的对象是 CompoundSelect
.
类似的 union()
方法可用于所有 FromClause
子类。
sqlalchemy.sql.expression.
union_all
(*selects, **kwargs)¶返回A UNION ALL
多个可选择的。
返回的对象是 CompoundSelect
.
类似的 union_all()
方法可用于所有 FromClause
子类。
sqlalchemy.sql.expression.
Alias
(*arg, **kw)¶基地: sqlalchemy.sql.expression.FromClause
表示表或可选别名(as)。
表示别名,通常应用于SQL语句中使用 AS
关键字(或在某些数据库(如Oracle)上不带关键字)。
此对象是由 alias()
模块级功能以及 FromClause.alias()
方法适用于所有 FromClause
子类。
__eq__
¶继承 __eq__
属性 object
返回self==值。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
alias
(name=None, flat=False)¶继承 alias()
方法 FromClause
返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
c
¶继承 c
属性 FromClause
的别名 columns
属性。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
description
¶对fromClause的简要描述。
主要用于错误消息格式。
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
get_children
(column_collections=True, **kw)¶返回此的直接子元素 ClauseElement
.
用于访问遍历。
* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。
is_derived_from
(fromclause)¶如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 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
params
(*optionaldict, **kwargs)¶继承 params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
返回此条款的副本 bindparam()
用给定字典中的值替换的元素::
>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
select
(whereclause=None, **params)¶继承 select()
方法 FromClause
返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
self_group
(against=None)¶对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
unique_params
(*optionaldict, **kwargs)¶继承 unique_params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
功能与 params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。
sqlalchemy.sql.expression.
CompoundSelect
(keyword, *selects, **kwargs)¶基地: sqlalchemy.sql.expression.GenerativeSelect
UNION
, UNION ALL
等选择基于集合的操作。
__eq__
¶继承 __eq__
属性 object
返回self==值。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
alias
(name=None, flat=False)¶继承 alias()
方法 FromClause
返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
append_group_by
(*clauses)¶附加应用于此可选项的给定分组条件。
标准将按标准附加到任何现有的组中。
这是一个 in-place 突变法 group_by()
方法是首选的,因为它提供了标准 method chaining .
append_order_by
(*clauses)¶附加应用于此可选项的给定排序条件。
标准将按标准附加到任何预先存在的订单。
这是一个 in-place 突变法 order_by()
方法是首选的,因为它提供了标准 method chaining .
apply_labels
()¶将“使用标签”标志设置为“真”时返回一个新的可选项。
这将导致使用表名标签生成列表达式,例如“选择somecolumn作为table name_somecolumn”。这允许包含多个FROM子句的可选项生成一组唯一的列名,而不管各个FROM子句之间的名称冲突如何。
as_scalar
()¶继承 as_scalar()
方法 SelectBase
返回此可选项的“标量”表示形式,它可以用作列表达式。
通常,只有一列的SELECT语句可以用作标量表达式。
返回的对象是 ScalarSelect
.
autocommit
()¶继承 autocommit()
方法 SelectBase
将“自动提交”标志设置为“真”时返回一个新的可选项。
0.6 版后已移除: 这个 SelectBase.autocommit()
方法已弃用,将在将来的版本中删除。请使用 Connection.execution_options.autocommit
参数与 Executable.execution_options()
方法。
bind
¶返回 Engine
或 Connection
对此 Executable
是绑定的,如果未找到,则为无。
这是一个遍历,它在本地进行检查,然后在关联对象的“from”子句之间进行检查,直到找到绑定的引擎或连接为止。
c
¶继承 c
属性 FromClause
的别名 columns
属性。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
cte
(name=None, recursive=False)¶返回一个新的 CTE
或公用表表达式实例。
公共表表达式是一种SQL标准,通过该标准,select语句可以使用名为“with”的子句,利用随主语句一起指定的辅助语句。还可以使用与union相关的特殊语义来允许“递归”查询,其中select语句可以根据以前选择的行集进行绘制。
CTE还可以应用于某些数据库上的DML构造更新、插入和删除,既可以作为与返回结合时CTE行的源,也可以作为CTE行的使用者。
SQLAlchemy检测 CTE
对象,其处理方式与 Alias
对象,作为要传递到语句的FROM子句以及语句顶部的WITH子句的特殊元素。
在 1.1 版更改: 添加了对更新/插入/删除作为CTE的支持,将CTE添加到更新/插入/删除。
以下示例包括来自PostgreSQL文档http://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)
参见
orm.query.Query.cte()
-ORM版本 HasCTE.cte()
.
description
¶继承 description
属性 FromClause
对fromClause的简要描述。
主要用于错误消息格式。
execute
(*multiparams, **params)¶继承 execute()
方法 Executable
编译并执行此 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()
完整的选项列表。
for_update
¶继承 for_update
属性 GenerativeSelect
为提供传统方言支持 for_update
属性。
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
get_children
(column_collections=True, **kwargs)¶返回此的直接子元素 ClauseElement
.
用于访问遍历。
* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。
get_execution_options
()¶获取将在执行期间生效的非SQL选项。
1.3 新版功能.
group_by
(*clauses)¶继承 group_by()
方法 GenerativeSelect
返回一个新的可选项,并应用给定的按条件分组列表。
标准将按标准附加到任何现有的组中。
is_derived_from
(fromclause)¶如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
label
(name)¶继承 label()
方法 SelectBase
返回此可选的“标量”表示形式,嵌入为带标签的子查询。
参见
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
limit
(limit)¶继承 limit()
方法 GenerativeSelect
返回一个新的可选项,并应用给定的限制条件。
这是一个数值,通常呈现为 LIMIT
结果选择中的表达式。不支持的后端 LIMIT
将尝试提供类似的功能。
在 1.0.0 版更改: - Select.limit()
can now
accept arbitrary SQL expressions as well as integer values.
limit¶ -- 整数限制参数或提供整数结果的SQL表达式。
offset
(offset)¶继承 offset()
方法 GenerativeSelect
返回一个新的可选项,并应用给定的偏移条件。
这是一个数值,通常呈现为 OFFSET
结果选择中的表达式。不支持的后端 OFFSET
将尝试提供类似的功能。
在 1.0.0 版更改: - Select.offset()
can now
accept arbitrary SQL expressions as well as integer values.
offset¶ -- 整数偏移量参数或提供整数结果的SQL表达式。
order_by
(*clauses)¶继承 order_by()
方法 GenerativeSelect
返回一个新的可选项,并应用给定的按条件排序列表。
标准将按标准附加到任何预先存在的订单。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 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
params
(*optionaldict, **kwargs)¶继承 params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
返回此条款的副本 bindparam()
用给定字典中的值替换的元素::
>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
scalar
(*multiparams, **params)¶继承 scalar()
方法 Executable
编译并执行此 Executable
,返回结果的标量表示。
select
(whereclause=None, **params)¶继承 select()
方法 FromClause
返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
self_group
(against=None)¶对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
unique_params
(*optionaldict, **kwargs)¶继承 unique_params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
功能与 params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。
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
也被指定。…添加的版本:1.1.0
key_share¶ -- 布尔值,将呈现 FOR NO KEY UPDATE
,或者如果与 read=True
将渲染 FOR KEY SHARE
在PostgreSQL方言上。…添加的版本:1.1.0
sqlalchemy.sql.expression.
CTE
(*arg, **kw)¶基地: sqlalchemy.sql.expression.Generative
, sqlalchemy.sql.expression.HasSuffixes
, sqlalchemy.sql.expression.Alias
表示公用表表达式。
这个 CTE
对象是使用 SelectBase.cte()
方法。有关完整的示例,请参见该方法。
__eq__
¶继承 __eq__
属性 object
返回self==值。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
alias
(name=None, flat=False)¶返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
c
¶继承 c
属性 FromClause
的别名 columns
属性。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
description
¶继承 description
属性 Alias
对fromClause的简要描述。
主要用于错误消息格式。
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
get_children
(column_collections=True, **kw)¶继承 get_children()
方法 Alias
返回此的直接子元素 ClauseElement
.
用于访问遍历。
* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。
is_derived_from
(fromclause)¶继承 is_derived_from()
方法 Alias
如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 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
params
(*optionaldict, **kwargs)¶继承 params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
返回此条款的副本 bindparam()
用给定字典中的值替换的元素::
>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
select
(whereclause=None, **params)¶继承 select()
方法 FromClause
返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
self_group
(against=None)¶继承 self_group()
方法 Alias
对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
suffix_with
(*expr, **kw)¶继承 suffix_with()
方法 HasSuffixes
在语句后面整体添加一个或多个表达式。
这用于在某些构造上支持后端特定的后缀关键字。
例如。::
stmt = select([col1, col2]).cte().suffix_with(
"cycle empno set y_cycle to 1 default 0", dialect="oracle")
可以通过多次调用指定多个后缀 suffix_with()
.
*expr¶ -- 文本或 ClauseElement
构造,将在target子句之后呈现。…警告:: HasSuffixes.suffix_with.*expr
参数 HasSuffixes.suffix_with()
可以作为python字符串参数传递,该参数将被视为 可信SQL文本 并按规定呈现。 不要将不受信任的输入传递给此参数 .
**kw¶ -- 只接受一个关键字“dialect”。这是一个可选的字符串方言名称,它将此后缀的呈现限制为仅限于该方言。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
unique_params
(*optionaldict, **kwargs)¶继承 unique_params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
功能与 params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。
sqlalchemy.sql.expression.
Executable
¶基地: sqlalchemy.sql.expression.Generative
将条款标记为支持执行。
Executable
是所有“语句”类型对象的超类,包括 select()
, delete()
, update()
, insert()
, text()
.
bind
¶返回 Engine
或 Connection
对此 Executable
是绑定的,如果未找到,则为无。
这是一个遍历,它在本地进行检查,然后在关联对象的“from”子句之间进行检查,直到找到绑定的引擎或连接为止。
execute
(*multiparams, **params)¶编译并执行此 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()
完整的选项列表。
get_execution_options
()¶获取将在执行期间生效的非SQL选项。
1.3 新版功能.
scalar
(*multiparams, **params)¶编译并执行此 Executable
,返回结果的标量表示。
sqlalchemy.sql.expression.
FromClause
¶基地: sqlalchemy.sql.expression.Selectable
表示可以在 FROM
A的子句 SELECT
语句。
最常见的形式 FromClause
是 Table
以及 select()
构造。所有人共同的主要特征 FromClause
对象包括:
一 c
集合,它提供对集合的按名称访问 ColumnElement
对象。
一 primary_key
属性,它是所有这些属性的集合 ColumnElement
指示 primary_key
标志。
生成“from”子句的各种派生的方法,包括 FromClause.alias()
, FromClause.join()
, FromClause.select()
.
alias
(name=None, flat=False)¶返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
columns
¶基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
description
¶对fromClause的简要描述。
主要用于错误消息格式。
foreign_keys
¶返回此FromClause引用的ForeignKey对象的集合。
is_derived_from
(fromclause)¶如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
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
lateral
(name=None)¶返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
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
primary_key
¶返回包含此FromClause的主键的列对象集合。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
schema
= None¶为此定义“schema”属性 FromClause
.
这是典型的 None
对于大多数对象,除了 Table
,其中它被视为 Table.schema
争论。
select
(whereclause=None, **params)¶返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
tablesample
(sampling, name=None, seed=None)¶返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
sqlalchemy.sql.expression.
GenerativeSelect
(use_labels=False, for_update=False, limit=None, offset=None, order_by=None, group_by=None, bind=None, autocommit=None)¶基地: sqlalchemy.sql.expression.SelectBase
可添加其他元素的select语句的基类。
这是 Select
和 CompoundSelect
其中可以添加order by、group by等元素,并控制列呈现。比较 TextAsFrom
当它子类 SelectBase
它也是一个select构造,表示一个固定的文本字符串,在这个级别上不能更改,只能包装为一个子查询。
0.9.0 新版功能: GenerativeSelect
添加以提供特定于 Select
和 CompoundSelect
同时允许 SelectBase
用于其他类似选择的对象,例如 TextAsFrom
.
__eq__
¶继承 __eq__
属性 object
返回self==值。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
alias
(name=None, flat=False)¶继承 alias()
方法 FromClause
返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
append_group_by
(*clauses)¶附加应用于此可选项的给定分组条件。
标准将按标准附加到任何现有的组中。
这是一个 in-place 突变法 group_by()
方法是首选的,因为它提供了标准 method chaining .
append_order_by
(*clauses)¶附加应用于此可选项的给定排序条件。
标准将按标准附加到任何预先存在的订单。
这是一个 in-place 突变法 order_by()
方法是首选的,因为它提供了标准 method chaining .
apply_labels
()¶将“使用标签”标志设置为“真”时返回一个新的可选项。
这将导致使用表名标签生成列表达式,例如“选择somecolumn作为table name_somecolumn”。这允许包含多个FROM子句的可选项生成一组唯一的列名,而不管各个FROM子句之间的名称冲突如何。
as_scalar
()¶继承 as_scalar()
方法 SelectBase
返回此可选项的“标量”表示形式,它可以用作列表达式。
通常,只有一列的SELECT语句可以用作标量表达式。
返回的对象是 ScalarSelect
.
autocommit
()¶继承 autocommit()
方法 SelectBase
将“自动提交”标志设置为“真”时返回一个新的可选项。
0.6 版后已移除: 这个 SelectBase.autocommit()
方法已弃用,将在将来的版本中删除。请使用 Connection.execution_options.autocommit
参数与 Executable.execution_options()
方法。
bind
¶继承 bind
属性 Executable
返回 Engine
或 Connection
对此 Executable
是绑定的,如果未找到,则为无。
这是一个遍历,它在本地进行检查,然后在关联对象的“from”子句之间进行检查,直到找到绑定的引擎或连接为止。
c
¶继承 c
属性 FromClause
的别名 columns
属性。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
cte
(name=None, recursive=False)¶返回一个新的 CTE
或公用表表达式实例。
公共表表达式是一种SQL标准,通过该标准,select语句可以使用名为“with”的子句,利用随主语句一起指定的辅助语句。还可以使用与union相关的特殊语义来允许“递归”查询,其中select语句可以根据以前选择的行集进行绘制。
CTE还可以应用于某些数据库上的DML构造更新、插入和删除,既可以作为与返回结合时CTE行的源,也可以作为CTE行的使用者。
SQLAlchemy检测 CTE
对象,其处理方式与 Alias
对象,作为要传递到语句的FROM子句以及语句顶部的WITH子句的特殊元素。
在 1.1 版更改: 添加了对更新/插入/删除作为CTE的支持,将CTE添加到更新/插入/删除。
以下示例包括来自PostgreSQL文档http://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)
参见
orm.query.Query.cte()
-ORM版本 HasCTE.cte()
.
description
¶继承 description
属性 FromClause
对fromClause的简要描述。
主要用于错误消息格式。
execute
(*multiparams, **params)¶继承 execute()
方法 Executable
编译并执行此 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()
完整的选项列表。
for_update
¶为提供传统方言支持 for_update
属性。
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
get_children
(**kwargs)¶继承 get_children()
方法 ClauseElement
返回此的直接子元素 ClauseElement
.
用于访问遍历。
* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。
get_execution_options
()¶获取将在执行期间生效的非SQL选项。
1.3 新版功能.
group_by
(*clauses)¶返回一个新的可选项,并应用给定的按条件分组列表。
标准将按标准附加到任何现有的组中。
is_derived_from
(fromclause)¶继承 is_derived_from()
方法 FromClause
如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
label
(name)¶继承 label()
方法 SelectBase
返回此可选的“标量”表示形式,嵌入为带标签的子查询。
参见
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
limit
(limit)¶返回一个新的可选项,并应用给定的限制条件。
这是一个数值,通常呈现为 LIMIT
结果选择中的表达式。不支持的后端 LIMIT
将尝试提供类似的功能。
在 1.0.0 版更改: - Select.limit()
can now
accept arbitrary SQL expressions as well as integer values.
limit¶ -- 整数限制参数或提供整数结果的SQL表达式。
offset
(offset)¶返回一个新的可选项,并应用给定的偏移条件。
这是一个数值,通常呈现为 OFFSET
结果选择中的表达式。不支持的后端 OFFSET
将尝试提供类似的功能。
在 1.0.0 版更改: - Select.offset()
can now
accept arbitrary SQL expressions as well as integer values.
offset¶ -- 整数偏移量参数或提供整数结果的SQL表达式。
order_by
(*clauses)¶返回一个新的可选项,并应用给定的按条件排序列表。
标准将按标准附加到任何预先存在的订单。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 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
params
(*optionaldict, **kwargs)¶继承 params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
返回此条款的副本 bindparam()
用给定字典中的值替换的元素::
>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
scalar
(*multiparams, **params)¶继承 scalar()
方法 Executable
编译并执行此 Executable
,返回结果的标量表示。
select
(whereclause=None, **params)¶继承 select()
方法 FromClause
返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
self_group
(against=None)¶继承 self_group()
方法 ClauseElement
对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
unique_params
(*optionaldict, **kwargs)¶继承 unique_params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
功能与 params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。
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
也被指定。…添加的版本:1.1.0
key_share¶ -- 布尔值,将呈现 FOR NO KEY UPDATE
,或者如果与 read=True
将渲染 FOR KEY SHARE
在PostgreSQL方言上。…添加的版本:1.1.0
sqlalchemy.sql.expression.
HasCTE
¶声明类以包含CTE支持的mixin。
1.1 新版功能.
cte
(name=None, recursive=False)¶返回一个新的 CTE
或公用表表达式实例。
公共表表达式是一种SQL标准,通过该标准,select语句可以使用名为“with”的子句,利用随主语句一起指定的辅助语句。还可以使用与union相关的特殊语义来允许“递归”查询,其中select语句可以根据以前选择的行集进行绘制。
CTE还可以应用于某些数据库上的DML构造更新、插入和删除,既可以作为与返回结合时CTE行的源,也可以作为CTE行的使用者。
SQLAlchemy检测 CTE
对象,其处理方式与 Alias
对象,作为要传递到语句的FROM子句以及语句顶部的WITH子句的特殊元素。
在 1.1 版更改: 添加了对更新/插入/删除作为CTE的支持,将CTE添加到更新/插入/删除。
以下示例包括来自PostgreSQL文档http://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)
参见
orm.query.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")
可以通过多次调用指定多个前缀 prefix_with()
.
*expr¶ -- 文本或 ClauseElement
在插入、更新或删除关键字后呈现的构造。…警告:: HasPrefixes.prefix_with.*expr
参数 HasPrefixes.prefix_with()
可以作为python字符串参数传递,该参数将被视为 可信SQL文本 并按规定呈现。 不要将不受信任的输入传递给此参数 .
**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")
可以通过多次调用指定多个后缀 suffix_with()
.
*expr¶ -- 文本或 ClauseElement
构造,将在target子句之后呈现。…警告:: HasSuffixes.suffix_with.*expr
参数 HasSuffixes.suffix_with()
可以作为python字符串参数传递,该参数将被视为 可信SQL文本 并按规定呈现。 不要将不受信任的输入传递给此参数 .
**kw¶ -- 只接受一个关键字“dialect”。这是一个可选的字符串方言名称,它将此后缀的呈现限制为仅限于该方言。
sqlalchemy.sql.expression.
Join
(left, right, onclause=None, isouter=False, full=False)¶基地: sqlalchemy.sql.expression.FromClause
代表一个 JOIN
在两者之间构建 FromClause
元素。
的公共构造函数函数 Join
模块级别 join()
函数,以及 FromClause.join()
任意方法 FromClause
(例如 Table
)
__eq__
¶继承 __eq__
属性 object
返回self==值。
__init__
(left, right, onclause=None, isouter=False, full=False)¶构建新的 Join
.
这里通常的入口点是 join()
函数或 FromClause.join()
任意方法 FromClause
对象。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
alias
(sqlutil, name=None, flat=False)¶返回此的别名 Join
.
这里的默认行为是首先从中生成一个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).\
with_labels(True).\
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()
任何可选方法。
0.9.0 新版功能: 增加了 flat=True
选项创建连接的“别名”,而不在select子查询中封闭。
参见
c
¶继承 c
属性 FromClause
的别名 columns
属性。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
description
¶对fromClause的简要描述。
主要用于错误消息格式。
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
get_children
(**kwargs)¶返回此的直接子元素 ClauseElement
.
用于访问遍历。
* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。
is_derived_from
(fromclause)¶如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 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
params
(*optionaldict, **kwargs)¶继承 params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
返回此条款的副本 bindparam()
用给定字典中的值替换的元素::
>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
select
(whereclause=None, **kwargs)¶等效的长手形,给定 Join
对象 j
是:
from sqlalchemy import select
j = select([j.left, j.right], **kw).\
where(whereclause).\
select_from(j)
self_group
(against=None)¶对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
unique_params
(*optionaldict, **kwargs)¶继承 unique_params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
功能与 params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。
sqlalchemy.sql.expression.
Lateral
(*arg, **kw)¶基地: sqlalchemy.sql.expression.Alias
表示横向子查询。
此对象是由 lateral()
模块级功能以及 FromClause.lateral()
方法适用于所有 FromClause
子类。
虽然横向是SQL标准的一部分,但目前只有更新的PostgreSQL版本才支持这个关键字。
1.1 新版功能.
参见
横向相关 -使用概述。
__eq__
¶继承 __eq__
属性 object
返回self==值。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
alias
(name=None, flat=False)¶继承 alias()
方法 FromClause
返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
c
¶继承 c
属性 FromClause
的别名 columns
属性。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
description
¶继承 description
属性 Alias
对fromClause的简要描述。
主要用于错误消息格式。
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
get_children
(column_collections=True, **kw)¶继承 get_children()
方法 Alias
返回此的直接子元素 ClauseElement
.
用于访问遍历。
* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。
is_derived_from
(fromclause)¶继承 is_derived_from()
方法 Alias
如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 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
params
(*optionaldict, **kwargs)¶继承 params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
返回此条款的副本 bindparam()
用给定字典中的值替换的元素::
>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
select
(whereclause=None, **params)¶继承 select()
方法 FromClause
返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
self_group
(against=None)¶继承 self_group()
方法 Alias
对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
unique_params
(*optionaldict, **kwargs)¶继承 unique_params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
功能与 params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。
sqlalchemy.sql.expression.
ScalarSelect
(element)¶基地: sqlalchemy.sql.expression.Generative
, sqlalchemy.sql.expression.Grouping
self_group
(**kwargs)¶对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
where
(crit)¶将WHERE子句应用于此引用的SELECT语句 ScalarSelect
.
sqlalchemy.sql.expression.
Select
(columns=None, whereclause=None, from_obj=None, distinct=False, having=None, correlate=True, prefixes=None, suffixes=None, **kwargs)¶基地: sqlalchemy.sql.expression.HasPrefixes
, sqlalchemy.sql.expression.HasSuffixes
, sqlalchemy.sql.expression.GenerativeSelect
表示 SELECT
语句。
__eq__
¶继承 __eq__
属性 object
返回self==值。
__init__
(columns=None, whereclause=None, from_obj=None, distinct=False, having=None, correlate=True, prefixes=None, suffixes=None, **kwargs)¶构建新的 Select
对象。
此构造函数被镜像为公共API函数;请参见 select()
完整的用法和参数描述。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
alias
(name=None, flat=False)¶继承 alias()
方法 FromClause
返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
append_column
(column)¶将给定的列表达式附加到此select()构造的columns子句中。
例如。::
my_select.append_column(some_table.c.new_column)
这是一个 in-place 突变法 column()
方法是首选的,因为它提供了标准 method chaining .
参见文档 Select.with_only_columns()
有关添加/替换 Select
对象。
append_correlation
(fromclause)¶将给定的相关表达式附加到此select()构造。
这是一个 in-place 突变法 correlate()
方法是首选的,因为它提供了标准 method chaining .
append_from
(fromclause)¶将给定的FromClause表达式附加到此select()构造的From子句中。
这是一个 in-place 突变法 select_from()
方法是首选的,因为它提供了标准 method chaining .
append_group_by
(*clauses)¶附加应用于此可选项的给定分组条件。
标准将按标准附加到任何现有的组中。
这是一个 in-place 突变法 group_by()
方法是首选的,因为它提供了标准 method chaining .
append_having
(having)¶将给定表达式附加到此select()构造的having条件。
表达式将通过和连接到现有的具有条件。
这是一个 in-place 突变法 having()
方法是首选的,因为它提供了标准 method chaining .
append_order_by
(*clauses)¶附加应用于此可选项的给定排序条件。
标准将按标准附加到任何预先存在的订单。
这是一个 in-place 突变法 order_by()
方法是首选的,因为它提供了标准 method chaining .
append_prefix
(clause)¶将给定的columns子句前缀表达式附加到此select()构造中。
这是一个 in-place 突变法 prefix_with()
方法是首选的,因为它提供了标准 method chaining .
append_whereclause
(whereclause)¶将给定表达式附加到此select()构造的where条件。
表达式将通过和连接到现有的Where条件。
这是一个 in-place 突变法 where()
方法是首选的,因为它提供了标准 method chaining .
apply_labels
()¶将“使用标签”标志设置为“真”时返回一个新的可选项。
这将导致使用表名标签生成列表达式,例如“选择somecolumn作为table name_somecolumn”。这允许包含多个FROM子句的可选项生成一组唯一的列名,而不管各个FROM子句之间的名称冲突如何。
as_scalar
()¶继承 as_scalar()
方法 SelectBase
返回此可选项的“标量”表示形式,它可以用作列表达式。
通常,只有一列的SELECT语句可以用作标量表达式。
返回的对象是 ScalarSelect
.
autocommit
()¶继承 autocommit()
方法 SelectBase
将“自动提交”标志设置为“真”时返回一个新的可选项。
0.6 版后已移除: 这个 SelectBase.autocommit()
方法已弃用,将在将来的版本中删除。请使用 Connection.execution_options.autocommit
参数与 Executable.execution_options()
方法。
bind
¶返回 Engine
或 Connection
对此 Executable
是绑定的,如果未找到,则为无。
这是一个遍历,它在本地进行检查,然后在关联对象的“from”子句之间进行检查,直到找到绑定的引擎或连接为止。
c
¶继承 c
属性 FromClause
的别名 columns
属性。
column
(column)¶返回一个新的select()构造,并将给定的列表达式添加到其columns子句中。
例如。::
my_select = my_select.column(table.c.new_column)
参见文档 Select.with_only_columns()
有关添加/替换 Select
对象。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
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映射类)将成为相关集合的一部分。
correlate_except
(*fromclauses)¶返回一个新的 Select
它将从自相关过程中省略给定的FROM子句。
调用 Select.correlate_except()
关掉 Select
对象对于给定的源元素的“自动相关”默认行为。此处指定的元素将无条件地显示在“发件人”列表中,而所有其他“发件人”元素都将服从正常的自动相关行为。
如果 None
通过, Select
对象将关联其所有源项。
*fromclauses¶ -- 一个或多个列表 FromClause
构造或其他兼容的构造(即ORM映射类)将成为相关异常集合的一部分。
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
cte
(name=None, recursive=False)¶返回一个新的 CTE
或公用表表达式实例。
公共表表达式是一种SQL标准,通过该标准,select语句可以使用名为“with”的子句,利用随主语句一起指定的辅助语句。还可以使用与union相关的特殊语义来允许“递归”查询,其中select语句可以根据以前选择的行集进行绘制。
CTE还可以应用于某些数据库上的DML构造更新、插入和删除,既可以作为与返回结合时CTE行的源,也可以作为CTE行的使用者。
SQLAlchemy检测 CTE
对象,其处理方式与 Alias
对象,作为要传递到语句的FROM子句以及语句顶部的WITH子句的特殊元素。
在 1.1 版更改: 添加了对更新/插入/删除作为CTE的支持,将CTE添加到更新/插入/删除。
以下示例包括来自PostgreSQL文档http://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)
参见
orm.query.Query.cte()
-ORM版本 HasCTE.cte()
.
description
¶继承 description
属性 FromClause
对fromClause的简要描述。
主要用于错误消息格式。
distinct
(*expr)¶返回将对其columns子句应用distinct的新select()构造。
*expr¶ -- 可选列表达式。当存在时,PostgreSQL方言将呈现 DISTINCT ON (<expressions>>)
构造。
except_
(other, **kwargs)¶针对给定的可选对象返回一个除此select()构造之外的SQL。
except_all
(other, **kwargs)¶返回一个SQL,除了针对给定可选对象的所有select()构造。
execute
(*multiparams, **params)¶继承 execute()
方法 Executable
编译并执行此 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()
完整的选项列表。
for_update
¶继承 for_update
属性 GenerativeSelect
为提供传统方言支持 for_update
属性。
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
froms
¶返回显示的fromclause元素列表。
get_children
(column_collections=True, **kwargs)¶根据子句元素规范返回子元素。
get_execution_options
()¶获取将在执行期间生效的非SQL选项。
1.3 新版功能.
group_by
(*clauses)¶继承 group_by()
方法 GenerativeSelect
返回一个新的可选项,并应用给定的按条件分组列表。
标准将按标准附加到任何现有的组中。
having
(having)¶返回一个新的select()构造,将给定表达式添加到HAVING子句中,通过和(如果有)联接到现有子句中。
inner_columns
¶将呈现到生成的select语句的columns子句中的所有columnelement表达式的迭代器。
intersect
(other, **kwargs)¶针对给定的可选对象返回此select()构造的SQL交集。
intersect_all
(other, **kwargs)¶返回一个SQL与给定的可选对象相交的select()构造。
is_derived_from
(fromclause)¶如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
label
(name)¶继承 label()
方法 SelectBase
返回此可选的“标量”表示形式,嵌入为带标签的子查询。
参见
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
limit
(limit)¶继承 limit()
方法 GenerativeSelect
返回一个新的可选项,并应用给定的限制条件。
这是一个数值,通常呈现为 LIMIT
结果选择中的表达式。不支持的后端 LIMIT
将尝试提供类似的功能。
在 1.0.0 版更改: - Select.limit()
can now
accept arbitrary SQL expressions as well as integer values.
limit¶ -- 整数限制参数或提供整数结果的SQL表达式。
locate_all_froms
()¶返回此select引用的所有fromclause元素的集合。
此集合是由 froms
属性,专门用于实际呈现的fromclause元素。
offset
(offset)¶继承 offset()
方法 GenerativeSelect
返回一个新的可选项,并应用给定的偏移条件。
这是一个数值,通常呈现为 OFFSET
结果选择中的表达式。不支持的后端 OFFSET
将尝试提供类似的功能。
在 1.0.0 版更改: - Select.offset()
can now
accept arbitrary SQL expressions as well as integer values.
offset¶ -- 整数偏移量参数或提供整数结果的SQL表达式。
order_by
(*clauses)¶继承 order_by()
方法 GenerativeSelect
返回一个新的可选项,并应用给定的按条件排序列表。
标准将按标准附加到任何预先存在的订单。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 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
params
(*optionaldict, **kwargs)¶继承 params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
返回此条款的副本 bindparam()
用给定字典中的值替换的元素::
>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
prefix_with
(*expr, **kw)¶继承 prefix_with()
方法 HasPrefixes
在语句关键字后添加一个或多个表达式,即select、insert、update或delete。生成的。
这用于支持后端特定的前缀关键字,如mysql提供的前缀关键字。
例如。::
stmt = table.insert().prefix_with("LOW_PRIORITY", dialect="mysql")
可以通过多次调用指定多个前缀 prefix_with()
.
*expr¶ -- 文本或 ClauseElement
在插入、更新或删除关键字后呈现的构造。…警告:: HasPrefixes.prefix_with.*expr
参数 HasPrefixes.prefix_with()
可以作为python字符串参数传递,该参数将被视为 可信SQL文本 并按规定呈现。 不要将不受信任的输入传递给此参数 .
**kw¶ -- 只接受一个关键字“dialect”。这是一个可选的字符串方言名称,它将此前缀的呈现限制为仅显示该方言。
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
reduce_columns
(sqlutil, only_synonyms=True)¶返回一个新的:func`。select`construct,从columns子句中删除了具有冗余名称、等价值的列。
这里的“冗余”是指两列,其中一列引用另一列,要么基于外键,要么通过在语句的WHERE子句中进行简单的相等比较。此方法的主要目的是自动构造一个具有所有唯一命名列的select语句,而不需要将表限定标签用作 apply_labels()
做。
当根据外键省略列时,引用的列是保留的列。当根据WhereEquivalence省略列时,column s子句中的第一列就是保留的列。
only_synonyms¶ -- 如果为true,则将删除列的操作限制为与等效项同名的操作。否则,将删除与另一列等效的所有列。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
scalar
(*multiparams, **params)¶继承 scalar()
方法 Executable
编译并执行此 Executable
,返回结果的标量表示。
select
(whereclause=None, **params)¶继承 select()
方法 FromClause
返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
select_from
(fromclause)¶返回一个新的 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)
self_group
(against=None)¶根据ClauseElement规范返回“Grouping”构造。
这将生成一个可以嵌入到表达式中的元素。请注意,在构造表达式时,此方法是根据需要自动调用的,不需要显式使用。
suffix_with
(*expr, **kw)¶继承 suffix_with()
方法 HasSuffixes
在语句后面整体添加一个或多个表达式。
这用于在某些构造上支持后端特定的后缀关键字。
例如。::
stmt = select([col1, col2]).cte().suffix_with(
"cycle empno set y_cycle to 1 default 0", dialect="oracle")
可以通过多次调用指定多个后缀 suffix_with()
.
*expr¶ -- 文本或 ClauseElement
构造,将在target子句之后呈现。…警告:: HasSuffixes.suffix_with.*expr
参数 HasSuffixes.suffix_with()
可以作为python字符串参数传递,该参数将被视为 可信SQL文本 并按规定呈现。 不要将不受信任的输入传递给此参数 .
**kw¶ -- 只接受一个关键字“dialect”。这是一个可选的字符串方言名称,它将此后缀的呈现限制为仅限于该方言。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
union
(other, **kwargs)¶针对给定的可选对象返回此select()构造的SQL联合。
union_all
(other, **kwargs)¶针对给定的可选对象返回一个sql union all this select()构造。
unique_params
(*optionaldict, **kwargs)¶继承 unique_params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
功能与 params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。
where
(whereclause)¶返回一个新的select()构造,并将给定表达式添加到其where子句中,通过and(如果有)联接到现有子句。
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
也被指定。…添加的版本:1.1.0
key_share¶ -- 布尔值,将呈现 FOR NO KEY UPDATE
,或者如果与 read=True
将渲染 FOR KEY SHARE
在PostgreSQL方言上。…添加的版本:1.1.0
with_hint
(selectable, text, dialect_name='*')¶为给定的可选对象添加索引或其他执行上下文提示 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')
with_only_columns
(columns)¶返回一个新的 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])
这意味着,如果新的列列表不再包含来自以下列的子句,则只从列列表派生的FROM子句将被丢弃:
>>> table1 = table('t1', column('a'), column('b'))
>>> table2 = table('t2', column('a'), column('b'))
>>> s1 = select([table1.c.a, table2.c.b])
>>> print s1
SELECT t1.a, t2.b FROM t1, t2
>>> s2 = s1.with_only_columns([table2.c.b])
>>> print s2
SELECT t2.b FROM t1
在构造中维护特定FROM子句的首选方法是使用 Select.select_from()
::
>>> s1 = select([table1.c.a, table2.c.b]).\
... select_from(table1.join(table2,
... table1.c.a==table2.c.a))
>>> s2 = s1.with_only_columns([table2.c.b])
>>> print s2
SELECT t2.b FROM t1 JOIN t2 ON t1.a=t2.a
还应注意使用传递给 Select.with_only_columns()
. 因为方法本质上等同于调用 select()
首先用给定的列构造,将列传递给 Select.with_only_columns()
通常应该是传递给 select()
构造,而不是从 .c
收集 select()
. 即:
s = select([table1.c.a, table1.c.b]).select_from(table1)
s = s.with_only_columns([table1.c.b])
和 not ::
# usually incorrect
s = s.with_only_columns([s.c.b])
后者将生成SQL::
SELECT b
FROM (SELECT t1.a AS a, t1.b AS b
FROM t1), t1
自从 select()
构造基本上被要求从 table1
以及它本身。
with_statement_hint
(text, dialect_name='*')¶在此添加语句提示 Select
.
这种方法类似于 Select.with_hint()
但它不需要单独的表,而是作为一个整体应用于语句。
这里的提示特定于后端数据库,可能包括诸如隔离级别、文件指令、fetch指令等指令。
1.0.0 新版功能.
sqlalchemy.sql.expression.
Selectable
¶基地: sqlalchemy.sql.expression.ClauseElement
将类标记为可选
sqlalchemy.sql.expression.
SelectBase
¶基地: sqlalchemy.sql.expression.HasCTE
, sqlalchemy.sql.expression.Executable
, sqlalchemy.sql.expression.FromClause
select语句的基类。
这包括 Select
, CompoundSelect
和 TextAsFrom
.
__eq__
¶继承 __eq__
属性 object
返回self==值。
__init__
¶继承 __init__
属性 object
初始化自身。请参阅帮助(键入(self))以获得准确的签名。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
alias
(name=None, flat=False)¶继承 alias()
方法 FromClause
返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
as_scalar
()¶返回此可选项的“标量”表示形式,它可以用作列表达式。
通常,只有一列的SELECT语句可以用作标量表达式。
返回的对象是 ScalarSelect
.
autocommit
()¶将“自动提交”标志设置为“真”时返回一个新的可选项。
0.6 版后已移除: 这个 SelectBase.autocommit()
方法已弃用,将在将来的版本中删除。请使用 Connection.execution_options.autocommit
参数与 Executable.execution_options()
方法。
bind
¶继承 bind
属性 Executable
返回 Engine
或 Connection
对此 Executable
是绑定的,如果未找到,则为无。
这是一个遍历,它在本地进行检查,然后在关联对象的“from”子句之间进行检查,直到找到绑定的引擎或连接为止。
c
¶继承 c
属性 FromClause
的别名 columns
属性。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
cte
(name=None, recursive=False)¶返回一个新的 CTE
或公用表表达式实例。
公共表表达式是一种SQL标准,通过该标准,select语句可以使用名为“with”的子句,利用随主语句一起指定的辅助语句。还可以使用与union相关的特殊语义来允许“递归”查询,其中select语句可以根据以前选择的行集进行绘制。
CTE还可以应用于某些数据库上的DML构造更新、插入和删除,既可以作为与返回结合时CTE行的源,也可以作为CTE行的使用者。
SQLAlchemy检测 CTE
对象,其处理方式与 Alias
对象,作为要传递到语句的FROM子句以及语句顶部的WITH子句的特殊元素。
在 1.1 版更改: 添加了对更新/插入/删除作为CTE的支持,将CTE添加到更新/插入/删除。
以下示例包括来自PostgreSQL文档http://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)
参见
orm.query.Query.cte()
-ORM版本 HasCTE.cte()
.
description
¶继承 description
属性 FromClause
对fromClause的简要描述。
主要用于错误消息格式。
execute
(*multiparams, **params)¶继承 execute()
方法 Executable
编译并执行此 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()
完整的选项列表。
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
get_children
(**kwargs)¶继承 get_children()
方法 ClauseElement
返回此的直接子元素 ClauseElement
.
用于访问遍历。
* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。
get_execution_options
()¶获取将在执行期间生效的非SQL选项。
1.3 新版功能.
is_derived_from
(fromclause)¶继承 is_derived_from()
方法 FromClause
如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
label
(name)¶返回此可选的“标量”表示形式,嵌入为带标签的子查询。
参见
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 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
params
(*optionaldict, **kwargs)¶继承 params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
返回此条款的副本 bindparam()
用给定字典中的值替换的元素::
>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
scalar
(*multiparams, **params)¶继承 scalar()
方法 Executable
编译并执行此 Executable
,返回结果的标量表示。
select
(whereclause=None, **params)¶继承 select()
方法 FromClause
返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
self_group
(against=None)¶继承 self_group()
方法 ClauseElement
对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
unique_params
(*optionaldict, **kwargs)¶继承 unique_params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
功能与 params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。
sqlalchemy.sql.expression.
TableClause
(name, *columns)¶基地: sqlalchemy.sql.expression.Immutable
, sqlalchemy.sql.expression.FromClause
表示最小的“表”构造。
这是一个轻量级表对象,它只有一个名称和一组列,通常由 expression.column()
功能:
from sqlalchemy import table, column
user = table("user",
column("id"),
column("name"),
column("description"),
)
这个 TableClause
构造是更常用的 Table
对象,提供 FromClause
服务包括 .c.
集合和语句生成方法。
它确实 not 提供的所有其他架构级服务 Table
,包括约束、对其他表的引用或对 MetaData
-水平服务。它本身作为一个特别的结构很有用,当一个更成熟的 Table
不在手边。
__eq__
¶继承 __eq__
属性 object
返回self==值。
__init__
(name, *columns)¶构建新的 TableClause
对象。
此构造函数被镜像为公共API函数;请参见 table()
完整的用法和参数描述。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
alias
(name=None, flat=False)¶继承 alias()
方法 FromClause
返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
c
¶继承 c
属性 FromClause
的别名 columns
属性。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
delete
(dml, whereclause=None, **kwargs)¶生成一个 delete()
在此基础上构建 TableClause
.
例如。::
table.delete().where(table.c.id==7)
见 delete()
获取参数和用法信息。
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
get_children
(column_collections=True, **kwargs)¶返回此的直接子元素 ClauseElement
.
用于访问遍历。
* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。
implicit_returning
= False¶TableClause
不支持主键或列级默认值,因此隐式返回不适用。
insert
(dml, values=None, inline=False, **kwargs)¶生成 insert()
在此基础上构建 TableClause
.
例如。::
table.insert().values(name='foo')
见 insert()
获取参数和用法信息。
is_derived_from
(fromclause)¶继承 is_derived_from()
方法 FromClause
如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 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
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
select
(whereclause=None, **params)¶继承 select()
方法 FromClause
返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
self_group
(against=None)¶继承 self_group()
方法 ClauseElement
对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
update
(dml, whereclause=None, values=None, inline=False, **kwargs)¶生成 update()
在此基础上构建 TableClause
.
例如。::
table.update().where(table.c.id==7).values(name='foo')
见 update()
获取参数和用法信息。
sqlalchemy.sql.expression.
TableSample
(*arg, **kw)¶基地: sqlalchemy.sql.expression.Alias
表示tablesample子句。
此对象是由 tablesample()
模块级功能以及 FromClause.tablesample()
方法适用于所有 FromClause
子类。
1.1 新版功能.
__eq__
¶继承 __eq__
属性 object
返回self==值。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
alias
(name=None, flat=False)¶继承 alias()
方法 FromClause
返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
c
¶继承 c
属性 FromClause
的别名 columns
属性。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
description
¶继承 description
属性 Alias
对fromClause的简要描述。
主要用于错误消息格式。
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
get_children
(column_collections=True, **kw)¶继承 get_children()
方法 Alias
返回此的直接子元素 ClauseElement
.
用于访问遍历。
* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。
is_derived_from
(fromclause)¶继承 is_derived_from()
方法 Alias
如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 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
params
(*optionaldict, **kwargs)¶继承 params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
返回此条款的副本 bindparam()
用给定字典中的值替换的元素::
>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
select
(whereclause=None, **params)¶继承 select()
方法 FromClause
返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
self_group
(against=None)¶继承 self_group()
方法 Alias
对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
unique_params
(*optionaldict, **kwargs)¶继承 unique_params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
功能与 params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。
sqlalchemy.sql.expression.
TextAsFrom
(text, columns, positional=False)¶基地: sqlalchemy.sql.expression.SelectBase
包装一个 TextClause
在一个 SelectBase
接口。
这允许 TextClause
要获得的对象 .c
收集和其他类似功能,例如 FromClause.alias()
, SelectBase.cte()
等。
这个 TextAsFrom
构造是通过 TextClause.columns()
方法-有关详细信息,请参见该方法。
0.9.0 新版功能.
__eq__
¶继承 __eq__
属性 object
返回self==值。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
alias
(name=None, flat=False)¶继承 alias()
方法 FromClause
返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
as_scalar
()¶继承 as_scalar()
方法 SelectBase
返回此可选项的“标量”表示形式,它可以用作列表达式。
通常,只有一列的SELECT语句可以用作标量表达式。
返回的对象是 ScalarSelect
.
autocommit
()¶继承 autocommit()
方法 SelectBase
将“自动提交”标志设置为“真”时返回一个新的可选项。
0.6 版后已移除: 这个 SelectBase.autocommit()
方法已弃用,将在将来的版本中删除。请使用 Connection.execution_options.autocommit
参数与 Executable.execution_options()
方法。
bind
¶继承 bind
属性 Executable
返回 Engine
或 Connection
对此 Executable
是绑定的,如果未找到,则为无。
这是一个遍历,它在本地进行检查,然后在关联对象的“from”子句之间进行检查,直到找到绑定的引擎或连接为止。
c
¶继承 c
属性 FromClause
的别名 columns
属性。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
cte
(name=None, recursive=False)¶返回一个新的 CTE
或公用表表达式实例。
公共表表达式是一种SQL标准,通过该标准,select语句可以使用名为“with”的子句,利用随主语句一起指定的辅助语句。还可以使用与union相关的特殊语义来允许“递归”查询,其中select语句可以根据以前选择的行集进行绘制。
CTE还可以应用于某些数据库上的DML构造更新、插入和删除,既可以作为与返回结合时CTE行的源,也可以作为CTE行的使用者。
SQLAlchemy检测 CTE
对象,其处理方式与 Alias
对象,作为要传递到语句的FROM子句以及语句顶部的WITH子句的特殊元素。
在 1.1 版更改: 添加了对更新/插入/删除作为CTE的支持,将CTE添加到更新/插入/删除。
以下示例包括来自PostgreSQL文档http://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)
参见
orm.query.Query.cte()
-ORM版本 HasCTE.cte()
.
description
¶继承 description
属性 FromClause
对fromClause的简要描述。
主要用于错误消息格式。
execute
(*multiparams, **params)¶继承 execute()
方法 Executable
编译并执行此 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()
完整的选项列表。
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
get_children
(**kwargs)¶继承 get_children()
方法 ClauseElement
返回此的直接子元素 ClauseElement
.
用于访问遍历。
* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。
get_execution_options
()¶获取将在执行期间生效的非SQL选项。
1.3 新版功能.
is_derived_from
(fromclause)¶继承 is_derived_from()
方法 FromClause
如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
label
(name)¶继承 label()
方法 SelectBase
返回此可选的“标量”表示形式,嵌入为带标签的子查询。
参见
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 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
params
(*optionaldict, **kwargs)¶继承 params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
返回此条款的副本 bindparam()
用给定字典中的值替换的元素::
>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
scalar
(*multiparams, **params)¶继承 scalar()
方法 Executable
编译并执行此 Executable
,返回结果的标量表示。
select
(whereclause=None, **params)¶继承 select()
方法 FromClause
返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
self_group
(against=None)¶继承 self_group()
方法 ClauseElement
对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
unique_params
(*optionaldict, **kwargs)¶继承 unique_params()
方法 ClauseElement
返回副本 bindparam()
元素被替换。
功能与 params()
,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。