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

术语“可选”是指可以从中选择行的任何对象;在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 .

* 选择

一览表 Select 实例。

* *克沃斯

可用关键字参数与 select() .

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

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

返回的对象是 CompoundSelect .

* 选择

一览表 Select 实例。

* *克沃斯

可用关键字参数与 select() .

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 .

* 选择

一览表 Select 实例。

* *克沃斯

可用关键字参数与 select() .

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

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

返回的对象是 CompoundSelect .

* 选择

一览表 Select 实例。

* *克沃斯

可用关键字参数与 select() .

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

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

例如。::

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

将沿着以下行发出SQL::

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

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

参数
  • left -- 连接的左侧。

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

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

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

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

参见

FromClause.join() -方法形式,基于给定的左侧

Join -生成的对象类型

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 .

参数
  • left -- 连接的左侧。

  • right -- 连接的右侧。

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

要将连接链结在一起,请使用 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() 构造。

参见

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

参数
sqlalchemy.sql.expression.subquery(alias, *args, **kwargs)

返回一 Alias 从派生的对象 Select .

名称

别名

* ARGS, * *克沃斯

所有其他参数都传递到 select() 功能。

sqlalchemy.sql.expression.table(name, *columns)

产生新的 TableClause .

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

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

参数
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 子类。

* 选择

一览表 Select 实例。

* *克沃斯

可用关键字参数与 select() .

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

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

返回的对象是 CompoundSelect .

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

* 选择

一览表 Select 实例。

* *克沃斯

可用关键字参数与 select() .

class 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 .

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 -- 安 EngineConnection 从哪一个 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 通过一个共同的祖先列。

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

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

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

参见

join() -独立函数

Join -生成的对象类型

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表达式。如果留在 NoneFromClause.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)

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

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

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

基地: sqlalchemy.sql.expression.GenerativeSelect

构成 UNIONUNION 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

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

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

c

继承 c 属性 FromClause

的别名 columns 属性。

columns

继承 columns 属性 FromClause

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

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 -- 安 EngineConnection 从哪一个 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 通过一个共同的祖先列。

参数
count(functions, whereclause=None, **params)

继承 count() 方法 FromClause

返回为此生成的选择计数 FromClause .

1.1 版后已移除: 这个 FromClause.count() 方法已弃用,将在将来的版本中删除。请使用 functions.count 功能可从 func 命名空间。

cte(name=None, recursive=False)

继承 cte() 方法 HasCTE

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

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

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

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

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

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

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

以下示例包括来自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(column_collections=True, **kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

get_execution_options()

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

1.3 新版功能.

group_by(*clauses)

返回一个新的可选项,并应用给定的按条件分组列表。

标准将按标准附加到任何现有的组中。

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

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

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

参见

join() -独立函数

Join -生成的对象类型

label(name)

继承 label() 方法 SelectBase

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

参见

as_scalar() .

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)

返回一个新的可选项,并应用给定的按条件排序列表。

标准将按标准附加到任何预先存在的订单。

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表达式。如果留在 NoneFromClause.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)

返回副本 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

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

基地: sqlalchemy.sql.expression.Generativesqlalchemy.sql.expression.HasSuffixessqlalchemy.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 .

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 -- 安 EngineConnection 从哪一个 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 通过一个共同的祖先列。

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

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

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

参见

join() -独立函数

Join -生成的对象类型

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表达式。如果留在 NoneFromClause.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)

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

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

class sqlalchemy.sql.expression.Executable

基地: sqlalchemy.sql.expression.Generative

将条款标记为支持执行。

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

bind

返回 EngineConnection 对此 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 ,返回结果的标量表示。

class sqlalchemy.sql.expression.FromClause

基地: sqlalchemy.sql.expression.Selectable

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

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

alias(name=None, flat=False)

返回此的别名 FromClause .

这是调用的简写:

from sqlalchemy import alias
a = alias(self, name=name)

alias() 有关详细信息。

c

的别名 columns 属性。

columns

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

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

select([mytable]).where(mytable.c.somecolumn == 5)
correspond_on_equivalents(column, equivalents)

返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。

corresponding_column(column, require_embedded=False)

给出了一个 ColumnElement ,返回导出的 ColumnElement 来自此的对象 Selectable 与原件相对应 Column 通过一个共同的祖先列。

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

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

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

参见

join() -独立函数

Join -生成的对象类型

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表达式。如果留在 NoneFromClause.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() -使用指南和参数

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

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

0.9.0 新版功能: GenerativeSelect 添加以提供特定于 SelectCompoundSelect 同时允许 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

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

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

c

继承 c 属性 FromClause

的别名 columns 属性。

columns

继承 columns 属性 FromClause

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

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 -- 安 EngineConnection 从哪一个 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 通过一个共同的祖先列。

参数
count(functions, whereclause=None, **params)

继承 count() 方法 FromClause

返回为此生成的选择计数 FromClause .

1.1 版后已移除: 这个 FromClause.count() 方法已弃用,将在将来的版本中删除。请使用 functions.count 功能可从 func 命名空间。

cte(name=None, recursive=False)

继承 cte() 方法 HasCTE

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

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

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

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

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

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

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

以下示例包括来自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)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

get_execution_options()

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

1.3 新版功能.

group_by(*clauses)

返回一个新的可选项,并应用给定的按条件分组列表。

标准将按标准附加到任何现有的组中。

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

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

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

参见

join() -独立函数

Join -生成的对象类型

label(name)

继承 label() 方法 SelectBase

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

参见

as_scalar() .

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表达式。如果留在 NoneFromClause.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)

返回副本 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

class 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添加到更新/插入/删除。

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

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

以下示例包括来自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() .

class 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”。这是一个可选的字符串方言名称,它将此前缀的呈现限制为仅显示该方言。

class 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”。这是一个可选的字符串方言名称,它将此后缀的呈现限制为仅限于该方言。

class 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子查询中封闭。

参数
  • name -- 给别名的名称。

  • flat -- 如果为真,则生成此的左右两侧的别名 Join 并返回这两个可选择项的联接。这将生成不包含封闭选择的联接表达式。…版本已添加::0.9.0

参见

alias()

c

继承 c 属性 FromClause

的别名 columns 属性。

columns

继承 columns 属性 FromClause

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

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 -- 安 EngineConnection 从哪一个 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 通过一个共同的祖先列。

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

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

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

参见

join() -独立函数

Join -生成的对象类型

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表达式。如果留在 NoneFromClause.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)

创建一个 Select 由此 Join .

等效的长手形,给定 Join 对象 j 是:

from sqlalchemy import select
j = select([j.left, j.right], **kw).\
            where(whereclause).\
            select_from(j)
参数
  • whereclause -- 将发送到 select() 功能

  • **kwargs -- 所有其他Kwarg都发送到底层 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)

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

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

class 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 .

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 -- 安 EngineConnection 从哪一个 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 通过一个共同的祖先列。

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

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

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

参见

join() -独立函数

Join -生成的对象类型

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表达式。如果留在 NoneFromClause.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)

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

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

class sqlalchemy.sql.expression.ScalarSelect(element)

基地: sqlalchemy.sql.expression.Generativesqlalchemy.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 .

class 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.HasPrefixessqlalchemy.sql.expression.HasSuffixessqlalchemy.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

返回 EngineConnection 对此 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 .

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 -- 安 EngineConnection 从哪一个 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 通过一个共同的祖先列。

参数
count(functions, whereclause=None, **params)

继承 count() 方法 FromClause

返回为此生成的选择计数 FromClause .

1.1 版后已移除: 这个 FromClause.count() 方法已弃用,将在将来的版本中删除。请使用 functions.count 功能可从 func 命名空间。

cte(name=None, recursive=False)

继承 cte() 方法 HasCTE

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

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

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

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

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

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

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

以下示例包括来自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 属性。

foreign_keys

继承 foreign_keys 属性 FromClause

返回此FromClause引用的ForeignKey对象的集合。

froms

返回显示的fromclause元素列表。

get_children(column_collections=True, **kwargs)

根据子句元素规范返回子元素。

get_execution_options()

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

1.3 新版功能.

group_by(*clauses)

返回一个新的可选项,并应用给定的按条件分组列表。

标准将按标准附加到任何现有的组中。

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

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

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

参见

join() -独立函数

Join -生成的对象类型

label(name)

继承 label() 方法 SelectBase

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

参见

as_scalar() .

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)

返回一个新的可选项,并应用给定的按条件排序列表。

标准将按标准附加到任何预先存在的订单。

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表达式。如果留在 NoneFromClause.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)

返回副本 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 .

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

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

将SQL呈现为:

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

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

select([mytable]).\
    with_hint(mytable, "index(%(name)s ix_mytable)", 'oracle').\
    with_hint(mytable, "WITH INDEX ix_mytable", 'sybase')
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 新版功能.

class sqlalchemy.sql.expression.Selectable

基地: sqlalchemy.sql.expression.ClauseElement

将类标记为可选

class sqlalchemy.sql.expression.SelectBase

基地: sqlalchemy.sql.expression.HasCTEsqlalchemy.sql.expression.Executablesqlalchemy.sql.expression.FromClause

select语句的基类。

这包括 SelectCompoundSelectTextAsFrom .

__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

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

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

c

继承 c 属性 FromClause

的别名 columns 属性。

columns

继承 columns 属性 FromClause

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

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 -- 安 EngineConnection 从哪一个 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 通过一个共同的祖先列。

参数
count(functions, whereclause=None, **params)

继承 count() 方法 FromClause

返回为此生成的选择计数 FromClause .

1.1 版后已移除: 这个 FromClause.count() 方法已弃用,将在将来的版本中删除。请使用 functions.count 功能可从 func 命名空间。

cte(name=None, recursive=False)

继承 cte() 方法 HasCTE

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

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

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

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

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

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

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

以下示例包括来自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)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

get_execution_options()

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

1.3 新版功能.

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

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

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

参见

join() -独立函数

Join -生成的对象类型

label(name)

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

参见

as_scalar() .

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表达式。如果留在 NoneFromClause.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)

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

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

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

基地: sqlalchemy.sql.expression.Immutablesqlalchemy.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 .

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 -- 安 EngineConnection 从哪一个 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 通过一个共同的祖先列。

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

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

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

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

参见

join() -独立函数

Join -生成的对象类型

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表达式。如果留在 NoneFromClause.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() 获取参数和用法信息。

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

基地: sqlalchemy.sql.expression.Alias

表示tablesample子句。

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

1.1 新版功能.

参见

tablesample()

__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 .

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 -- 安 EngineConnection 从哪一个 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 通过一个共同的祖先列。

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

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

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

参见

join() -独立函数

Join -生成的对象类型

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表达式。如果留在 NoneFromClause.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)

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

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

class 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

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

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

c

继承 c 属性 FromClause

的别名 columns 属性。

columns

继承 columns 属性 FromClause

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

这个 columnsc 集合,是使用表绑定或其他可选绑定列构造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 -- 安 EngineConnection 从哪一个 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 通过一个共同的祖先列。

参数
count(functions, whereclause=None, **params)

继承 count() 方法 FromClause

返回为此生成的选择计数 FromClause .

1.1 版后已移除: 这个 FromClause.count() 方法已弃用,将在将来的版本中删除。请使用 functions.count 功能可从 func 命名空间。

cte(name=None, recursive=False)

继承 cte() 方法 HasCTE

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

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

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

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

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

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

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

以下示例包括来自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)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

get_execution_options()

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

1.3 新版功能.

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

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

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

参见

join() -独立函数

Join -生成的对象类型

label(name)

继承 label() 方法 SelectBase

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

参见

as_scalar() .

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表达式。如果留在 NoneFromClause.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)

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

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