登录
目录
当前位置： 首页 > 文档资料 > SQLAlchemy 中文文档 >

列元素和表达式

优质
小牛编辑
141浏览
2023-12-01

表达式API由一系列类组成，每个类表示SQL字符串中的特定词汇元素。它们组合成一个更大的结构，形成一个语句结构 编译的 转换为可以传递给数据库的字符串表示形式。这些类被组织成一个从最底层开始的层次结构 ClauseElement 班级。关键子类包括 ColumnElement ，它表示SQL语句中任何基于列的表达式的角色，例如在columns子句、WHERE子句和ORDER BY子句中，以及 FromClause ，它表示放置在SELECT语句的FROM子句中的令牌的角色。

列元素基础构造函数

从中导入的独立函数 sqlalchemy 在构建SQLAlchemy表达式语言构造时使用的命名空间。

Object NameDescription

and_(*clauses)

生成由以下对象连接的表达式的连接 AND .

bindparam(key[, value, type_, unique, ...])

生成“绑定表达式”。

case(*whens, **kw)

产生一个 CASE 表达式。

cast(expression, type_)

产生一个 CAST 表达式。

column(text[, type_, is_literal, _selectable])

产生一个 ColumnClause 对象。

custom_op

表示“自定义”运算符。

distinct(expr)

生成列表达式级别一元 DISTINCT 条款。

extract(field, expr, **kwargs)

返回A Extract 构造。

false()

返回A False_ 构造。

func

生成SQL函数表达式。

lambda_stmt(lmb[, enable_tracking, track_closure_variables, track_on, ...])

生成缓存为lambda的SQL语句。

literal(value[, type_])

返回绑定到绑定参数的literal子句。

literal_column(text[, type_])

产生一个 ColumnClause 对象具有 column.is_literal 标志设置为真。

not_(clause)

返回给定子句的否定，即 NOT(clause) .

null()

返回常量 Null 构造。

or_(*clauses)

生成由以下对象连接的表达式的连接 OR .

outparam(key[, type_])

为支持函数（存储过程）的数据库创建用于函数（存储过程）的“out”参数。

quoted_name

表示结合引用首选项的SQL标识符。

text(text[, bind])

构建新的 TextClause 子句，直接表示文本SQL字符串。

true()

返回常量 True_ 构造。

tuple_(*clauses, **kw)

返回A Tuple .

type_coerce(expression, type_)

将SQL表达式与特定类型关联，而不呈现 CAST .

function sqlalchemy.sql.expression.and_(*clauses)

这里列出的函数通常作为方法从任何 ColumnElement 例如，构造 label() 函数通常通过 ColumnElement.label() 方法。

Object NameDescription

all_(expr)

生成一个all表达式。

any_(expr)

生成任意表达式。

asc(column)

产生一个上升的 ORDER BY 子句元素。

between(expr, lower_bound, upper_bound[, symmetric])

产生一个 BETWEEN 谓词子句。

collate(expression, collation)

退回条款 expression COLLATE collation .

desc(column)

生成降序 ORDER BY 子句元素。

funcfilter(func, *criterion)

产生一个 FunctionFilter 对象对函数。

label(name, element[, type_])

返回A Label 给定对象 ColumnElement .

nulls_first(column)

生产 NULLS FIRST AN的修饰符 ORDER BY 表达式。

nulls_last(column)

生产 NULLS LAST AN的修饰符 ORDER BY 表达式。

over(element[, partition_by, order_by, range_, ...])

产生一个 Over 对象对函数。

within_group(element, *order_by)

产生一个 WithinGroup 对象对函数。

function sqlalchemy.sql.expression.all_(expr)

这里的类是使用中列出的构造函数生成的 列元素基础构造函数 和 列元素修饰符构造函数 .

Object NameDescription

BinaryExpression

表示一个表达式 LEFT <operator> RIGHT .

BindParameter

表示“绑定表达式”。

CacheKey

Case

代表一个 CASE 表达式。

Cast

代表一个 CAST 表达式。

ClauseElement

以编程方式构造的SQL表达式的元素的基类。

ClauseList

描述由运算符分隔的子句列表。

ColumnClause

表示任何文本字符串中的列表达式。

ColumnCollection

集合 ColumnElement 实例，通常用于 FromClause 对象。

ColumnElement

表示一个面向列的SQL表达式，适用于语句的“columns”子句、where子句等。

ColumnOperators

为定义布尔、比较和其他运算符 ColumnElement 表达。

DialectKWArgs

建立一个类的能力，使其具有带有默认值和构造函数验证的方言特定参数。

Extract

表示一个SQL提取子句， extract(field FROM expr) .

False_

代表 false SQL语句中的关键字或等效项。

FunctionFilter

表示一个函数筛选子句。

Label

表示列标签（as）。

LambdaElement

一个SQL构造，其中状态存储为未调用的lambda。

Null

表示SQL语句中的空关键字。

Operators

比较和逻辑运算符的基础。

Over

表示一个over子句。

StatementLambdaElement

将可组合的SQL语句表示为 LambdaElement .

TextClause

表示文字SQL文本片段。

True_

代表 true SQL语句中的关键字或等效项。

Tuple

表示SQL元组。

TypeCoerce

表示Python端类型强制包装。

UnaryExpression

定义“一元”表达式。

WithinGroup

表示组内（order by）子句。

WrapsColumnExpression

定义一个 ColumnElement 作为对已具有名称的表达式具有特殊标记行为的包装器。

class sqlalchemy.sql.expression.BinaryExpression(left, right, operator, type_=None, negate=None, modifiers=None)

表示一个表达式 LEFT <operator> RIGHT .

A BinaryExpression 每当在python二进制表达式中使用两个列表达式时自动生成：

>>> from sqlalchemy.sql import column
>>> column('a') + column('b')
<sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>
>>> print(column('a') + column('b'))
a + b

类签名

class sqlalchemy.sql.expression.BinaryExpression (sqlalchemy.sql.expression.ColumnElement)

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

对此应用“分组” ClauseElement .

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

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

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

class sqlalchemy.sql.expression.BindParameter(key, value=symbol('NO_ARG'), type_=None, unique=False, required=symbol('NO_ARG'), quote=None, callable_=None, expanding=False, isoutparam=False, literal_execute=False, _compared_to_operator=None, _compared_to_type=None, _is_crud=False)

表示“绑定表达式”。

BindParameter 是使用 bindparam() 功能，如：

from sqlalchemy import bindparam

stmt = select(users_table).\
            where(users_table.c.name == bindparam('username'))

详细讨论如何 BindParameter 使用的是 bindparam() .

参见

bindparam()

类签名

class sqlalchemy.sql.expression.BindParameter (sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.BindParameter.__init__(key, value=symbol('NO_ARG'), type_=None, unique=False, required=symbol('NO_ARG'), quote=None, callable_=None, expanding=False, isoutparam=False, literal_execute=False, _compared_to_operator=None, _compared_to_type=None, _is_crud=False)

构建新的 BindParameter 对象。

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

attribute sqlalchemy.sql.expression.BindParameter.effective_value

返回此绑定参数的值，并考虑 callable 参数已设置。

这个 callable 值将被评估并返回（如果存在），否则 value .

method sqlalchemy.sql.expression.BindParameter.render_literal_execute()

生成此绑定参数的副本，它将启用 BindParameter.literal_execute 旗帜。

这个 BindParameter.literal_execute 标志将具有在编译的SQL字符串中呈现的参数的效果，使用 [POSTCOMPILE] 表单，它是一种特殊的表单，在SQL执行时转换为参数文字值的呈现形式。其基本原理是支持缓存SQL语句字符串，这些字符串可以在传递给DBAPI的最终SQL字符串中嵌入每个语句的文字值，如限制和偏移参数。尤其是方言可能希望在自定义编译方案中使用此方法。

1.4.5 新版功能.

参见

第三方方言的缓存

class sqlalchemy.sql.expression.CacheKey(key, bindparams)

类签名

class sqlalchemy.sql.expression.CacheKey (sqlalchemy.sql.traversals.CacheKey)

method sqlalchemy.sql.expression.CacheKey.to_offline_string(statement_cache, statement, parameters)

生成一个“脱机字符串”形式 CacheKey

“offline string”基本上是语句的字符串SQL加上绑定参数值的repr。鉴于 CacheKey 对象依赖于内存中的标识以便用作缓存键，“脱机”版本适用于也将用于其他进程的缓存。

给定的 statement_cache 是一个类似字典的对象，语句本身的字符串形式将被缓存。这个字典应该在一个较长的生存期内，以减少字符串化语句所花费的时间。

class sqlalchemy.sql.expression.Case(*whens, **kw)

代表一个 CASE 表达式。

Case 是使用 case() 工厂功能，如：

from sqlalchemy import case

stmt = select(users_table).                    where(
                case(
                    (users_table.c.name == 'wendy', 'W'),
                    (users_table.c.name == 'jack', 'J'),
                    else_='E'
                )
            )

细节 Case 用法是 case() .

参见

case()

类签名

class sqlalchemy.sql.expression.Case (sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.Case.__init__(*whens, **kw)

构建新的 Case 对象。

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

class sqlalchemy.sql.expression.Cast(expression, type_)

代表一个 CAST 表达式。

Cast 是使用 cast() 工厂功能，如：

from sqlalchemy import cast, Numeric

stmt = select(cast(product_table.c.unit_price, Numeric(10, 4)))

细节 Cast 用法是 cast() .

参见

数据强制转换和类型强制

cast()

type_coerce() -强制类型转换的另一种方法是只在Python端强制类型，这通常足以生成正确的SQL和数据强制。

类签名

class sqlalchemy.sql.expression.Cast (sqlalchemy.sql.expression.WrapsColumnExpression, sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.Cast.__init__(expression, type_)

构建新的 Cast 对象。

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

class sqlalchemy.sql.expression.ClauseElement

以编程方式构造的SQL表达式的元素的基类。

类签名

class sqlalchemy.sql.expression.ClauseElement (sqlalchemy.sql.roles.SQLRole, sqlalchemy.sql.annotation.SupportsWrappingAnnotations, sqlalchemy.sql.traversals.MemoizedHasCacheKey, sqlalchemy.sql.traversals.HasCopyInternals, sqlalchemy.sql.visitors.Traversible)

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

比较一下 ClauseElement 到给定的 ClauseElement .

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

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

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

编译此SQL表达式。

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

参数

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

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

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

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

参见

如何将SQL表达式呈现为字符串（可能是内联绑定参数）？

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

inherited from the Traversible.get_children() method of Traversible

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

用于访问遍历。

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

class memoized_attribute(fget, doc=None)

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

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

inherited from the HasMemoized.memoized_instancemethod() method of HasMemoized

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

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

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

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

>>> clause = column('x') + bindparam('foo')
>>> print(clause.compile().params)
{'foo':None}
>>> print(clause.params({'foo':7}).compile().params)
{'foo':7}
method sqlalchemy.sql.expression.ClauseElement.self_group(against=None)

对此应用“分组” ClauseElement .

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

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

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

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

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

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

class sqlalchemy.sql.expression.ClauseList(*clauses, **kwargs)

描述由运算符分隔的子句列表。

默认情况下，是逗号分隔的，例如列列表。

类签名

class sqlalchemy.sql.expression.ClauseList (sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.roles.OrderByRole, sqlalchemy.sql.roles.ColumnsClauseRole, sqlalchemy.sql.roles.DMLColumnRole, sqlalchemy.sql.expression.ClauseElement)

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

对此应用“分组” ClauseElement .

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

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

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

class sqlalchemy.sql.expression.ColumnClause(text, type_=None, is_literal=False, _selectable=None)

表示任何文本字符串中的列表达式。

这个 ColumnClause 一个轻量级的模拟 Column 类，通常使用 column() 功能，如：

from sqlalchemy import column

id, name = column("id"), column("name")
stmt = select(id, name).select_from("user")

上面的语句将生成类似SQL的：

SELECT id, name FROM user

ColumnClause 是模式特定的直接超类 Column 对象。而 Column 类具有与 ColumnClause , the ColumnClause 在行为需求仅限于简单的SQL表达式生成的情况下，类本身是可用的。对象没有与架构级元数据或执行时间行为的关联 Column 是的，所以在这个意义上是 Column .

详情 ColumnClause 用法是 column() .

参见

column()

Column

类签名

class sqlalchemy.sql.expression.ColumnClause (sqlalchemy.sql.roles.DDLReferredColumnRole, sqlalchemy.sql.roles.LabeledColumnExprRole, sqlalchemy.sql.roles.StrAsPlainColumnRole, sqlalchemy.sql.expression.Immutable, sqlalchemy.sql.expression.NamedColumn)

method sqlalchemy.sql.expression.ColumnClause.__init__(text, type_=None, is_literal=False, _selectable=None)

构建新的 ColumnClause 对象。

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

method sqlalchemy.sql.expression.ColumnClause.get_children(column_tables=False, **kw)

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

用于访问遍历。

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

class sqlalchemy.sql.expression.ColumnCollection(columns=None)

集合 ColumnElement 实例，通常用于 FromClause 对象。

这个 ColumnCollection 对象最常见的可用形式是 Table.c 或 Table.columns 上的集合 Table 对象，在 访问表和列 。

这个 ColumnCollection 具有类似映射和类似序列的行为。一个 ColumnCollection 通常在商店里 Column 对象，然后可以通过映射样式访问和属性访问样式访问这些对象。

要访问 Column 使用普通属性样式访问的对象，可以像指定任何其他对象属性一样指定名称，例如在名为 employee_name 已访问：

>>> employee_table.c.employee_name

要访问名称包含特殊字符或空格的列，可以使用索引式访问，如下所示说明了名为的列 employee ' payment 已访问：

>>> employee_table.c["employee ' payment"]

作为 ColumnCollection 对象提供了Python字典接口，常见的字典方法名称如下 ColumnCollection.keys() ， ColumnCollection.values() ，以及 ColumnCollection.items() 都是可用的，这意味着以这些名称为关键字的数据库列也需要使用索引访问：：

>>> employee_table.c["values"]

对象为其指定的名称 Column 将会出现的通常是 Column.key 参数。在某些上下文中，例如 Select 属性使用标签样式集的 Select.set_label_style() 方法时，某个键的列可以改用特定的标签名表示，例如 tablename_columnname ：：

>>> from sqlalchemy import select, column, table
>>> from sqlalchemy import LABEL_STYLE_TABLENAME_PLUS_COL
>>> t = table("t", column("c"))
>>> stmt = select(t).set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL)
>>> subq = stmt.subquery()
>>> subq.c.t_c
<sqlalchemy.sql.elements.ColumnClause at 0x7f59dcf04fa0; t_c>

ColumnCollection 同时按顺序索引列，并允许按整数位置访问它们：

>>> cc[0]
Column('x', Integer(), table=None)
>>> cc[1]
Column('y', Integer(), table=None)

1.4 新版功能: ColumnCollection 允许对集合进行基于整数的索引访问。

迭代集合将按以下顺序生成列表达式：

>>> list(cc)
[Column('x', Integer(), table=None),
 Column('y', Integer(), table=None)]

底座 ColumnCollection 对象可以存储重复项，这可能意味着具有相同键的两列中的任何一列，在这种情况下，键访问返回的列是 任意的 ：：

>>> x1, x2 = Column('x', Integer), Column('x', Integer)
>>> cc = ColumnCollection(columns=[(x1.name, x1), (x2.name, x2)])
>>> list(cc)
[Column('x', Integer(), table=None),
 Column('x', Integer(), table=None)]
>>> cc['x'] is x1
False
>>> cc['x'] is x2
True

也可以多次表示同一列。这些案例被支持为 ColumnCollection 用于表示select语句中可能包含重复项的列。

一个特殊的子类 DedupeColumnCollection 存在，它维护SQLAlchemy不允许重复的旧行为；此集合用于架构级对象，如 Table 和 PrimaryKeyConstraint 在这种情况下，除尘是有帮助的。这个 DedupeColumnCollection 类还具有其他的突变方法，因为模式构造具有更多需要删除和替换列的用例。

在 1.4 版更改: ColumnCollection 现在在多个位置存储重复的列键以及同一列。这个 DedupeColumnCollection 类用于在需要重复数据消除和其他替换/删除操作的情况下保持以前的行为。

method sqlalchemy.sql.expression.ColumnCollection.add(column, key=None)

向此添加一列 ColumnCollection 。

注解

此方法是 not normally used by user-facing code ，作为 ColumnCollection 通常是现有对象的一部分，如 Table 。要添加 Column 添加到现有的 Table 对象，请使用 Table.append_column() 方法。

method sqlalchemy.sql.expression.ColumnCollection.as_immutable()

返回此函数的“不可变”形式 ColumnCollection 。

method sqlalchemy.sql.expression.ColumnCollection.clear()

没有为以下对象实现字典清除() ColumnCollection 。

method sqlalchemy.sql.expression.ColumnCollection.compare(other)

比较一下这个 ColumnCollection 根据密钥的名称添加到另一个密钥

method sqlalchemy.sql.expression.ColumnCollection.contains_column(col)

检查此集合中是否存在列对象

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

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

参数

参见

Selectable.corresponding_column() -对返回的集合调用此方法 Selectable.exported_columns .

在 1.4 版更改: 实施 corresponding_column 被转移到 ColumnCollection 本身。

method sqlalchemy.sql.expression.ColumnCollection.get(key, default=None)

拿到一个 ColumnClause 或 Column 基于此中的字符串键名称创建 ColumnCollection 。

method sqlalchemy.sql.expression.ColumnCollection.items()

返回此集合中所有列的(key，column)元组序列，每个元组由字符串键名称和 ColumnClause 或 Column 对象。

method sqlalchemy.sql.expression.ColumnCollection.keys()

返回此集合中所有列的字符串键名称序列。

method sqlalchemy.sql.expression.ColumnCollection.remove(column)

字典Remove()未针对以下对象实现 ColumnCollection 。

method sqlalchemy.sql.expression.ColumnCollection.update(iter_)

字典update()未针对以下对象实现 ColumnCollection 。

method sqlalchemy.sql.expression.ColumnCollection.values()

返回一个序列 ColumnClause 或 Column 此集合中所有列的。

class sqlalchemy.sql.expression.ColumnElement

表示一个面向列的SQL表达式，适用于语句的“columns”子句、where子句等。

而最熟悉的那种 ColumnElement 是 Column 对象， ColumnElement 用作SQL表达式中可能存在的任何单元的基础，包括表达式本身、SQL函数、绑定参数、文本表达式、关键字，例如 NULL 等。 ColumnElement 是所有这些元素的最终基类。

各种各样的SQLAlchemy核心函数在SQL表达式级别上工作，并打算接受 ColumnElement 作为争论。这些函数通常会记录它们接受“SQL表达式”作为参数。这在sqlacalchemy中意味着什么，通常指的是一个已经以 ColumnElement 对象，或可以是 强制的 成一体。与SQL表达式相关的大多数（而不是全部）sqlAlchemy核心函数所遵循的强制规则如下：

  • python文本值，如字符串、整数或浮点值、布尔值、日期时间， Decimal 对象，或者几乎任何其他的python对象，将被强制为“文本绑定值”。这通常意味着 bindparam() 将生成具有嵌入到构造中的给定值的；结果 BindParameter 对象是的实例 ColumnElement . Python值最终将在执行时作为参数化参数发送给DBAPI execute() 或 executemany() 方法，在sqlacalchemy类型特定的转换器之后（例如由任何关联的 TypeEngine 对象）应用于该值。

  • 任何特殊的对象值，通常是ORM级构造，它具有一个调用的访问器 __clause_element__() . 当将其他未知类型的对象传递给要将参数强制为 ColumnElement 有时 SelectBase 表达式。它在ORM中用于从ORM特定对象（如映射类和映射属性）转换为核心表达式对象。

  • Python None 值通常解释为 NULL ，它在sqlacalchemy core中生成 null() .

A ColumnElement 提供生成新的 ColumnElement 使用python表达式的对象。这意味着python操作符，例如 == ， != 和 < 重载以模拟SQL操作，并允许进一步实例化 ColumnElement 由其他更基本的实例组成的实例 ColumnElement 物体。例如，两个 ColumnClause 对象可以与加法运算符一起添加 + 产生一个 BinaryExpression .两者都是 ColumnClause 和 BinaryExpression 是的子类 ColumnElement ：：

>>> from sqlalchemy.sql import column
>>> column('a') + column('b')
<sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>
>>> print(column('a') + column('b'))
a + b

参见

Column

column()

类签名

class sqlalchemy.sql.expression.ColumnElement (sqlalchemy.sql.roles.ColumnArgumentOrKeyRole, sqlalchemy.sql.roles.StatementOptionRole, sqlalchemy.sql.roles.WhereHavingRole, sqlalchemy.sql.roles.BinaryElementRole, sqlalchemy.sql.roles.OrderByRole, sqlalchemy.sql.roles.ColumnsClauseRole, sqlalchemy.sql.roles.LimitOffsetRole, sqlalchemy.sql.roles.DMLColumnRole, sqlalchemy.sql.roles.DDLConstraintColumnRole, sqlalchemy.sql.roles.DDLExpressionRole, sqlalchemy.sql.expression.ColumnOperators, sqlalchemy.sql.expression.ClauseElement)

method sqlalchemy.sql.expression.ColumnElement.__eq__(other)

inherited from the sqlalchemy.sql.expression.ColumnOperators.__eq__ method of ColumnOperators

实施 == 操作员。

在列上下文中，生成子句 a = b . 如果目标是 None 生产 a IS NULL .

method sqlalchemy.sql.expression.ColumnElement.__le__(other)

inherited from the sqlalchemy.sql.expression.ColumnOperators.__le__ method of ColumnOperators

实施 <= 操作员。

在列上下文中，生成子句 a <= b .

method sqlalchemy.sql.expression.ColumnElement.__lt__(other)

inherited from the sqlalchemy.sql.expression.ColumnOperators.__lt__ method of ColumnOperators

实施 < 操作员。

在列上下文中，生成子句 a < b .

method sqlalchemy.sql.expression.ColumnElement.__ne__(other)

inherited from the sqlalchemy.sql.expression.ColumnOperators.__ne__ method of ColumnOperators

实施 != 操作员。

在列上下文中，生成子句 a != b . 如果目标是 None 生产 a IS NOT NULL .

method sqlalchemy.sql.expression.ColumnElement.all_()

inherited from the ColumnOperators.all_() method of ColumnOperators

制作一个 all_() 子句对父对象执行操作。

请参阅的文档 all_() 举个例子。

注解

一定不要把新的弄糊涂了 ColumnOperators.all_() 方法及其较旧的 ARRAY -特定的对应方，即 Comparator.all() 方法，该方法使用不同的调用语法和使用模式。

1.1 新版功能.

attribute sqlalchemy.sql.expression.ColumnElement.allows_lambda = True
attribute sqlalchemy.sql.expression.ColumnElement.anon_key_label

1.4 版后已移除: 这个 ColumnElement.anon_key_label 属性现在是私有的，并且不推荐使用公共访问器。

attribute sqlalchemy.sql.expression.ColumnElement.anon_label

1.4 版后已移除: 这个 ColumnElement.anon_label 属性现在是私有的，并且不推荐使用公共访问器。

method sqlalchemy.sql.expression.ColumnElement.any_()

inherited from the ColumnOperators.any_() method of ColumnOperators

制作一个 any_() 子句对父对象执行操作。

请参阅的文档 any_() 举个例子。

注解

一定不要把新的弄糊涂了 ColumnOperators.any_() 方法及其较旧的 ARRAY -特定的对应方，即 Comparator.any() 方法，该方法使用不同的调用语法和使用模式。

1.1 新版功能.

method sqlalchemy.sql.expression.ColumnElement.asc()

inherited from the ColumnOperators.asc() method of ColumnOperators

产生一个 asc() 针对父对象的子句。

attribute sqlalchemy.sql.expression.ColumnElement.base_columns
method sqlalchemy.sql.expression.ColumnElement.between(cleft, cright, symmetric=False)

inherited from the ColumnOperators.between() method of ColumnOperators

产生一个 between() 在给定上下限的情况下，针对父对象的子句。

attribute sqlalchemy.sql.expression.ColumnElement.bind = None
method sqlalchemy.sql.expression.ColumnElement.bool_op(opstring, precedence=0)

inherited from the Operators.bool_op() method of Operators

返回自定义布尔运算符。

这个方法是调用 Operators.op() 并通过 Operators.op.is_comparison 标记为真。

参见

Operators.op()

method sqlalchemy.sql.expression.ColumnElement.cast(type_)

生成类型转换，即 CAST(<expression> AS <type>) .

这是到 cast() 功能。

参见

数据强制转换和类型强制

cast()

type_coerce()

1.0.7 新版功能.

method sqlalchemy.sql.expression.ColumnElement.collate(collation)

inherited from the ColumnOperators.collate() method of ColumnOperators

产生一个 collate() 在给定排序规则字符串的情况下，对父对象执行子句。

参见

collate()

attribute sqlalchemy.sql.expression.ColumnElement.comparator
method sqlalchemy.sql.expression.ColumnElement.compare(other, **kw)

inherited from the ClauseElement.compare() method of ClauseElement

比较一下 ClauseElement 到给定的 ClauseElement .

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

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

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

inherited from the ClauseElement.compile() method of ClauseElement

编译此SQL表达式。

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

参数

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

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

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

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

参见

如何将SQL表达式呈现为字符串（可能是内联绑定参数）？

method sqlalchemy.sql.expression.ColumnElement.concat(other)

inherited from the ColumnOperators.concat() method of ColumnOperators

实现“concat”运算符。

在列上下文中，生成子句 a || b 或使用 concat() mysql上的操作符。

method sqlalchemy.sql.expression.ColumnElement.contains(other, **kwargs)

inherited from the ColumnOperators.contains() method of ColumnOperators

实现“contains”运算符。

生成一个类似表达式，该表达式根据字符串值中间的匹配项进行测试：

column LIKE '%' || <other> || '%'

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.contains("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值， ColumnOperators.contains.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符，以便它们与自身匹配，而不是作为通配符匹配。或者， ColumnOperators.contains.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是文本字符串时可以使用该字符。

参数

  • other -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.contains.autoescape 标志设置为真。

  • autoescape -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.包含（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param |‘%‘ESCAPE’/”，值为 :param 作为 "foo/%bar" .

  • escape -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.contains（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.contains.autoescape ：：someColumn.contains（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

ColumnOperators.startswith()

ColumnOperators.endswith()

ColumnOperators.like()

method sqlalchemy.sql.expression.ColumnElement.desc()

inherited from the ColumnOperators.desc() method of ColumnOperators

产生一个 desc() 针对父对象的子句。

attribute sqlalchemy.sql.expression.ColumnElement.description = None
method sqlalchemy.sql.expression.ColumnElement.distinct()

inherited from the ColumnOperators.distinct() method of ColumnOperators

产生一个 distinct() 针对父对象的子句。

method sqlalchemy.sql.expression.ColumnElement.endswith(other, **kwargs)

inherited from the ColumnOperators.endswith() method of ColumnOperators

实现“endswith”运算符。

生成一个类似表达式，该表达式根据字符串值末尾的匹配项进行测试：

column LIKE '%' || <other>

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.endswith("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值， ColumnOperators.endswith.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符，以便它们与自身匹配，而不是作为通配符匹配。或者， ColumnOperators.endswith.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是文本字符串时可以使用该字符。

参数

  • other -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.endswith.autoescape 标志设置为真。

  • autoescape -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.endswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param ESCAPE“/”值为 :param 作为 "foo/%bar" .

  • escape -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.endswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param ESCAPE '^' The parameter may also be combined with ColumnOperators.endswith.autoescape ：：someColumn.endsWith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

ColumnOperators.startswith()

ColumnOperators.contains()

ColumnOperators.like()

attribute sqlalchemy.sql.expression.ColumnElement.entity_namespace

inherited from the ClauseElement.entity_namespace attribute of ClauseElement

attribute sqlalchemy.sql.expression.ColumnElement.expression

返回列表达式。

检查界面的一部分；返回自身。

attribute sqlalchemy.sql.expression.ColumnElement.foreign_keys = []
method sqlalchemy.sql.expression.ColumnElement.get_children(omit_attrs=(), **kw)

inherited from the Traversible.get_children() method of Traversible

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

用于访问遍历。

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

method sqlalchemy.sql.expression.ColumnElement.ilike(other, escape=None)

inherited from the ColumnOperators.ilike() method of ColumnOperators

实施 ilike 运算符，例如不区分大小写的like。

在列上下文中，生成以下任一形式的表达式：

lower(a) LIKE lower(other)

或者在支持ilike运算符的后端：

a ILIKE other

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.ilike("%foobar%"))
参数

  • other -- 要比较的表达式

  • escape -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.ilike（“foo/%bar”，escape=“/”）

参见

ColumnOperators.like()

method sqlalchemy.sql.expression.ColumnElement.in_(other)

inherited from the ColumnOperators.in_() method of ColumnOperators

实施 in 操作员。

在列上下文中，生成子句 column IN <other> .

给定参数 other 可能是：

  • 文字值列表，例如：

    stmt.where(column.in_([1, 2, 3]))

    在此调用表单中，项目列表将转换为一组与给定列表长度相同的绑定参数：

    WHERE COL IN (?, ?, ?)

  • 如果比较与 tuple_() 包含多个表达式：

    from sqlalchemy import tuple_
stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))

  • 空列表，例如：

    stmt.where(column.in_([]))

    在此调用形式中，表达式呈现“空集”表达式。这些表达式是针对各个后端量身定做的，通常会尝试将空的SELECT语句作为子查询。例如在SQLite上，表达式为：：

    WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

    在 1.4 版更改: 空IN表达式现在在所有情况下都使用生成的SELECT子查询的执行时间。

  • 绑定参数，例如 bindparam() ，如果包含 bindparam.expanding 旗帜：

    stmt.where(column.in_(bindparam('value', expanding=True)))

    在此调用表单中，表达式呈现一个特殊的非SQL占位符表达式，其外观如下：

    WHERE COL IN ([EXPANDING_value])

    此占位符表达式在语句执行时被截取，以便转换为前面所示的绑定参数表单的变量号。如果语句的执行方式为：

    connection.execute(stmt, {"value": [1, 2, 3]})

    将为数据库传递每个值的绑定参数：

    WHERE COL IN (?, ?, ?)

    1.2 新版功能: 添加了“扩展”绑定参数

    如果传递空列表，将呈现一个特定于正在使用的数据库的特殊“空列表”表达式。在sqlite上：

    WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

    1.3 新版功能: “expanding”绑定参数现在支持空列表

  • 一 select() 构造，通常是相关的标量选择：

    stmt.where(
    column.in_(
        select(othertable.c.y).
        where(table.c.x == othertable.c.x)
    )
)

    在这个调用表单中， ColumnOperators.in_() 按给定呈现：

    WHERE COL IN (SELECT othertable.y
FROM othertable WHERE othertable.x = table.x)
参数

other -- 文字列表，a select() 构造，或 bindparam() 构造，包括 bindparam.expanding 标志设置为真。

method sqlalchemy.sql.expression.ColumnElement.is_(other)

inherited from the ColumnOperators.is_() method of ColumnOperators

实施 IS 操作员。

通常情况下， IS 与以下值比较时自动生成 None ，决定 NULL . 但是，明确使用 IS 如果与某些平台上的布尔值进行比较，可能是可取的。

参见

ColumnOperators.is_not()

attribute sqlalchemy.sql.expression.ColumnElement.is_clause_element = True
method sqlalchemy.sql.expression.ColumnElement.is_distinct_from(other)

inherited from the ColumnOperators.is_distinct_from() method of ColumnOperators

实施 IS DISTINCT FROM 操作员。

在大多数平台上呈现“a与b不同”；在某些平台上，例如sqlite可能呈现“a不是b”。

1.1 新版功能.

method sqlalchemy.sql.expression.ColumnElement.is_not(other)

inherited from the ColumnOperators.is_not() method of ColumnOperators

实施 IS NOT 操作员。

通常情况下， IS NOT 与以下值比较时自动生成 None ，决定 NULL . 但是，明确使用 IS NOT 如果与某些平台上的布尔值进行比较，可能是可取的。

在 1.4 版更改: 这个 is_not() 运算符重命名自 isnot() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.is_()

method sqlalchemy.sql.expression.ColumnElement.is_not_distinct_from(other)

inherited from the ColumnOperators.is_not_distinct_from() method of ColumnOperators

实施 IS NOT DISTINCT FROM 操作员。

在大多数平台上呈现“a与b不同”；在某些平台上，例如sqlite可能呈现“a是b”。

在 1.4 版更改: 这个 is_not_distinct_from() 运算符重命名自 isnot_distinct_from() 在以前的版本中。以前的名称仍然可以向后兼容。

1.1 新版功能.

attribute sqlalchemy.sql.expression.ColumnElement.is_selectable = False
method sqlalchemy.sql.expression.ColumnElement.isnot(other)

inherited from the ColumnOperators.isnot() method of ColumnOperators

实施 IS NOT 操作员。

通常情况下， IS NOT 与以下值比较时自动生成 None ，决定 NULL . 但是，明确使用 IS NOT 如果与某些平台上的布尔值进行比较，可能是可取的。

在 1.4 版更改: 这个 is_not() 运算符重命名自 isnot() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.is_()

method sqlalchemy.sql.expression.ColumnElement.isnot_distinct_from(other)

inherited from the ColumnOperators.isnot_distinct_from() method of ColumnOperators

实施 IS NOT DISTINCT FROM 操作员。

在大多数平台上呈现“a与b不同”；在某些平台上，例如sqlite可能呈现“a是b”。

在 1.4 版更改: 这个 is_not_distinct_from() 运算符重命名自 isnot_distinct_from() 在以前的版本中。以前的名称仍然可以向后兼容。

1.1 新版功能.

attribute sqlalchemy.sql.expression.ColumnElement.key = None

在某些情况下在Python命名空间中引用此对象的“key”。

这通常指列的“键”，如 .c 可选择的集合，例如。 sometable.c["somekey"] 将返回 Column 用一个 .key 关于“somekey”。

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

生成列标签，即 <columnname> AS <name> .

这是到 label() 功能。

如果'name'是 None ，将生成匿名标签名称。

method sqlalchemy.sql.expression.ColumnElement.like(other, escape=None)

inherited from the ColumnOperators.like() method of ColumnOperators

实施 like 操作员。

在列上下文中，生成表达式：：

a LIKE other

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.like("%foobar%"))
参数

  • other -- 要比较的表达式

  • escape -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.like（“foo/%bar”，escape=“/”）

参见

ColumnOperators.ilike()

method sqlalchemy.sql.expression.ColumnElement.match(other, **kwargs)

inherited from the ColumnOperators.match() method of ColumnOperators

实现特定于数据库的“match”运算符。

ColumnOperators.match() 尝试解析为后端提供的类似匹配的函数或运算符。示例包括：

  • PostgreSQL-呈现 x @@ to_tsquery(y)

  • MySQL -渲染器 MATCH (x) AGAINST (y IN BOOLEAN MODE)

    参见

    match -具有附加功能的MySQL特定构造。

  • Oracle-呈现 CONTAINS(x, y)

  • 其他后端可能提供特殊的实现。

  • 没有任何特殊实现的后端将发出“match”操作符。例如，这与sqlite兼容。

class memoized_attribute(fget, doc=None)

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

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

inherited from the HasMemoized.memoized_instancemethod() method of HasMemoized

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

method sqlalchemy.sql.expression.ColumnElement.not_ilike(other, escape=None)

inherited from the ColumnOperators.not_ilike() method of ColumnOperators

实施 NOT ILIKE 操作员。

这相当于使用否定 ColumnOperators.ilike() ，即 ~x.ilike(y) .

在 1.4 版更改: 这个 not_ilike() 运算符重命名自 notilike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.ilike()

method sqlalchemy.sql.expression.ColumnElement.not_in(other)

inherited from the ColumnOperators.not_in() method of ColumnOperators

实施 NOT IN 操作员。

这相当于使用否定 ColumnOperators.in_() ，即 ~x.in_(y) .

在这种情况下 other 是一个空序列，编译器生成一个“empty not in”表达式。这将默认表达式“1=1”在所有情况下都生成“真”。这个 create_engine.empty_in_strategy 可用于更改此行为。

在 1.4 版更改: 这个 not_in() 运算符重命名自 notin_() 在以前的版本中。以前的名称仍然可以向后兼容。

在 1.2 版更改: 这个 ColumnOperators.in_() 和 ColumnOperators.not_in() 现在，默认情况下，运算符为空序列生成一个“静态”表达式。

参见

ColumnOperators.in_()

method sqlalchemy.sql.expression.ColumnElement.not_like(other, escape=None)

inherited from the ColumnOperators.not_like() method of ColumnOperators

实施 NOT LIKE 操作员。

这相当于使用否定 ColumnOperators.like() ，即 ~x.like(y) .

在 1.4 版更改: 这个 not_like() 运算符重命名自 notlike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.like()

method sqlalchemy.sql.expression.ColumnElement.notilike(other, escape=None)

inherited from the ColumnOperators.notilike() method of ColumnOperators

实施 NOT ILIKE 操作员。

这相当于使用否定 ColumnOperators.ilike() ，即 ~x.ilike(y) .

在 1.4 版更改: 这个 not_ilike() 运算符重命名自 notilike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.ilike()

method sqlalchemy.sql.expression.ColumnElement.notin_(other)

inherited from the ColumnOperators.notin_() method of ColumnOperators

实施 NOT IN 操作员。

这相当于使用否定 ColumnOperators.in_() ，即 ~x.in_(y) .

在这种情况下 other 是一个空序列，编译器生成一个“empty not in”表达式。这将默认表达式“1=1”在所有情况下都生成“真”。这个 create_engine.empty_in_strategy 可用于更改此行为。

在 1.4 版更改: 这个 not_in() 运算符重命名自 notin_() 在以前的版本中。以前的名称仍然可以向后兼容。

在 1.2 版更改: 这个 ColumnOperators.in_() 和 ColumnOperators.not_in() 现在，默认情况下，运算符为空序列生成一个“静态”表达式。

参见

ColumnOperators.in_()

method sqlalchemy.sql.expression.ColumnElement.notlike(other, escape=None)

inherited from the ColumnOperators.notlike() method of ColumnOperators

实施 NOT LIKE 操作员。

这相当于使用否定 ColumnOperators.like() ，即 ~x.like(y) .

在 1.4 版更改: 这个 not_like() 运算符重命名自 notlike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.like()

method sqlalchemy.sql.expression.ColumnElement.nulls_first()

inherited from the ColumnOperators.nulls_first() method of ColumnOperators

产生一个 nulls_first() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_first() 运算符重命名自 nullsfirst() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.sql.expression.ColumnElement.nulls_last()

inherited from the ColumnOperators.nulls_last() method of ColumnOperators

产生一个 nulls_last() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_last() 运算符重命名自 nullslast() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.sql.expression.ColumnElement.nullsfirst()

inherited from the ColumnOperators.nullsfirst() method of ColumnOperators

产生一个 nulls_first() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_first() 运算符重命名自 nullsfirst() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.sql.expression.ColumnElement.nullslast()

inherited from the ColumnOperators.nullslast() method of ColumnOperators

产生一个 nulls_last() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_last() 运算符重命名自 nullslast() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.sql.expression.ColumnElement.op(opstring, precedence=0, is_comparison=False, return_type=None)

inherited from the Operators.op() method of Operators

生成泛型运算符函数。

例如。：：

somecolumn.op("*")(5)

生产：：

somecolumn * 5

此函数还可用于显式地生成位运算符。例如：：

somecolumn.op('&')(0xff)

是中的值的位与 somecolumn .

参数

  • operator -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。

  • precedence -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时，较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (, ） AS 运算符。值100将大于或等于所有运算符，-100将小于或等于所有运算符。

  • is_comparison -- 如果为真，则该运算符将被视为“比较”运算符，即计算为布尔真/假值，如 == ， > 等等。应设置此标志，以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded:：0.9.2-添加了 Operators.op.is_comparison 旗帜。

  • return_type -- 一 TypeEngine 类或对象，它将强制此运算符生成的表达式的返回类型为该类型。默认情况下，指定 Operators.op.is_comparison 将决心 Boolean ，而那些不属于左侧操作数的类型。

参见

重新定义和创建新的运算符

在联接条件中使用自定义运算符

method sqlalchemy.sql.expression.ColumnElement.operate(op, *other, **kwargs)

对参数进行运算。

这是最低级别的操作，提升 NotImplementedError 默认情况下。

在子类上覆盖此项可以允许将公共行为应用于所有操作。例如，重写 ColumnOperators 申请 func.lower() 左右两侧：

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数

  • op -- 操作员可调用。

  • *other -- 操作的“另一方”。对于大多数操作，将是单个标量。

  • **kwargs -- 修饰语。这些可由特殊操作员通过，如 ColumnOperators.contains() .

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

inherited from the ClauseElement.params() method of ClauseElement

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

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

>>> clause = column('x') + bindparam('foo')
>>> print(clause.compile().params)
{'foo':None}
>>> print(clause.params({'foo':7}).compile().params)
{'foo':7}
attribute sqlalchemy.sql.expression.ColumnElement.primary_key = False
attribute sqlalchemy.sql.expression.ColumnElement.proxy_set
method sqlalchemy.sql.expression.ColumnElement.regexp_match(pattern, flags=None)

inherited from the ColumnOperators.regexp_match() method of ColumnOperators

实现特定于数据库的“regexp match”运算符。

例如。：：

stmt = select(table.c.some_column).where(
    table.c.some_column.regexp_match('^(b|c)')
)

ColumnOperators.regexp_match() 尝试解析为后端提供的类似REGEXP的函数或运算符，但是可用的特定正则表达式语法和标志是 不是后端不可知的 .

示例包括：

  • PostgreSQL-呈现 x ~ y 或 x !~ y 当被否定时。

  • Oracle-呈现 REGEXP_LIKE(x, y)

  • SQLite-使用SQLite的 REGEXP 占位符运算符和对Python的调用 re.match() 内置的。

  • 其他后端可能提供特殊的实现。

  • 没有任何特殊实现的后端将发出操作符“REGEXP”或“NOT REGEXP”。例如，这与SQLite和MySQL兼容。

正则表达式支持目前是针对Oracle、PostgreSQL、MySQL和MariaDB实现的。部分支持SQLite。第三方方言之间的支持可能会有所不同。

参数

  • pattern -- 正则表达式模式字符串或列子句。

  • flags -- 要应用的任何正则表达式字符串标志。标志往往是特定于后端的。它可以是字符串或列子句。一些后端，比如PostgreSQL和MariaDB，可以选择将标志指定为模式的一部分。在PostgreSQL中使用ignore case标志“i”时，ignore case regexp match运算符 ~* 或 !~* 将被使用。

1.4 新版功能.

参见

ColumnOperators.regexp_replace()

method sqlalchemy.sql.expression.ColumnElement.regexp_replace(pattern, replacement, flags=None)

inherited from the ColumnOperators.regexp_replace() method of ColumnOperators

实现特定于数据库的“regexp replace”运算符。

例如。：：

stmt = select(
    table.c.some_column.regexp_replace(
        'b(..)',
        'XY',
        flags='g'
    )
)

ColumnOperators.regexp_replace() 尝试解析为后端提供的类似REGEXP_REPLACE的函数，该函数通常发出该函数 REGEXP_REPLACE() . 但是，可用的特定正则表达式语法和标志是 不是后端不可知的 .

目前已为Oracle、PostgreSQL、MySQL8或更高版本和MariaDB实现正则表达式替换支持。第三方方言之间的支持可能会有所不同。

参数

  • pattern -- 正则表达式模式字符串或列子句。

  • pattern -- 替换字符串或列子句。

  • flags -- 要应用的任何正则表达式字符串标志。标志往往是特定于后端的。它可以是字符串或列子句。一些后端，比如PostgreSQL和MariaDB，可以选择将标志指定为模式的一部分。

1.4 新版功能.

参见

ColumnOperators.regexp_match()

method sqlalchemy.sql.expression.ColumnElement.reverse_operate(op, other, **kwargs)

对参数进行反向运算。

用法与 operate() .

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

对此应用“分组” ClauseElement .

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

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

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

method sqlalchemy.sql.expression.ColumnElement.shares_lineage(othercolumn)

如果给定 ColumnElement 有着共同的祖先 ColumnElement .

method sqlalchemy.sql.expression.ColumnElement.startswith(other, **kwargs)

inherited from the ColumnOperators.startswith() method of ColumnOperators

实施 startswith 操作员。

生成一个类似表达式，该表达式根据字符串值开头的匹配项进行测试：

column LIKE <other> || '%'

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.startswith("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值， ColumnOperators.startswith.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符，以便它们与自身匹配，而不是作为通配符匹配。或者， ColumnOperators.startswith.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是文本字符串时可以使用该字符。

参数

  • other -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.startswith.autoescape 标志设置为真。

  • autoescape -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.startswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，类似于：param |'%'ESCAPE'/'的值为 :param 作为 "foo/%bar" .

  • escape -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.startswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn-like :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.startswith.autoescape ：：somecolumn.startswith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

ColumnOperators.endswith()

ColumnOperators.contains()

ColumnOperators.like()

attribute sqlalchemy.sql.expression.ColumnElement.stringify_dialect = 'default'
attribute sqlalchemy.sql.expression.ColumnElement.supports_execution = False
attribute sqlalchemy.sql.expression.ColumnElement.timetuple = None

inherited from the ColumnOperators.timetuple attribute of ColumnOperators

hack，允许在lhs上比较datetime对象。

attribute sqlalchemy.sql.expression.ColumnElement.type
method sqlalchemy.sql.expression.ColumnElement.unique_params(*optionaldict, **kwargs)

inherited from the ClauseElement.unique_params() method of ClauseElement

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

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

attribute sqlalchemy.sql.expression.ColumnElement.uses_inspection = True
class sqlalchemy.sql.expression.ColumnOperators

为定义布尔、比较和其他运算符 ColumnElement 表达。

默认情况下，所有方法都调用 operate() 或 reverse_operate() ，从python内置函数传入适当的operator函数 operator 模块或特定于sqlAlchemy的运算符函数 sqlalchemy.expression.operators . 例如 __eq__ 功能：

def __eq__(self, other):
    return self.operate(operators.eq, other)

哪里 operators.eq 本质上是：：

def eq(a, b):
    return a == b

核心列表达式单元 ColumnElement 重写 Operators.operate() 还有其他人要回去 ColumnElement 构造，以便 == 上面的操作被子句构造替换。

参见

重新定义和创建新的运算符

TypeEngine.comparator_factory

ColumnOperators

PropComparator

类签名

class sqlalchemy.sql.expression.ColumnOperators (sqlalchemy.sql.expression.Operators)

method sqlalchemy.sql.expression.ColumnOperators.__add__(other)

实施 + 操作员。

在列上下文中，生成子句 a + b 如果父对象具有非字符串关联性。如果父对象具有字符串关联性，则生成串联运算符， a || b -见 ColumnOperators.concat() .

method sqlalchemy.sql.expression.ColumnOperators.__and__(other)

inherited from the sqlalchemy.sql.expression.Operators.__and__ method of Operators

实施 & 操作员。

当与SQL表达式一起使用时，将生成一个和操作，相当于 and_() ，即：

a & b

等于：

from sqlalchemy import and_
and_(a, b)

使用时应小心 & 关于运算符优先级； & 运算符具有最高优先级。如果操作数包含其他子表达式，则应将它们括在括号中：：

(a == 2) & (b == 4)
method sqlalchemy.sql.expression.ColumnOperators.__div__(other)

实施 / 操作员。

在列上下文中，生成子句 a / b .

method sqlalchemy.sql.expression.ColumnOperators.__eq__(other)

实施 == 操作员。

在列上下文中，生成子句 a = b . 如果目标是 None 生产 a IS NULL .

method sqlalchemy.sql.expression.ColumnOperators.__ge__(other)

实施 >= 操作员。

在列上下文中，生成子句 a >= b .

method sqlalchemy.sql.expression.ColumnOperators.__getitem__(index)

实现[]运算符。

这可以被一些特定于数据库的类型使用，如PostgreSQL数组和hstore。

method sqlalchemy.sql.expression.ColumnOperators.__gt__(other)

实施 > 操作员。

在列上下文中，生成子句 a > b .

method sqlalchemy.sql.expression.ColumnOperators.__hash__()

返回哈希（self）。

method sqlalchemy.sql.expression.ColumnOperators.__invert__()

inherited from the sqlalchemy.sql.expression.Operators.__invert__ method of Operators

实施 ~ 操作员。

当与SQL表达式一起使用时，会导致一个非操作，相当于 not_() ，即：

~a

等于：

from sqlalchemy import not_
not_(a)
method sqlalchemy.sql.expression.ColumnOperators.__le__(other)

实施 <= 操作员。

在列上下文中，生成子句 a <= b .

method sqlalchemy.sql.expression.ColumnOperators.__lshift__(other)

实现<<运算符。

不由sqlachemy core使用，这是为希望使用<<作为扩展点的自定义操作员系统提供的。

method sqlalchemy.sql.expression.ColumnOperators.__lt__(other)

实施 < 操作员。

在列上下文中，生成子句 a < b .

method sqlalchemy.sql.expression.ColumnOperators.__mod__(other)

实施 % 操作员。

在列上下文中，生成子句 a % b .

method sqlalchemy.sql.expression.ColumnOperators.__mul__(other)

实施 * 操作员。

在列上下文中，生成子句 a * b .

method sqlalchemy.sql.expression.ColumnOperators.__ne__(other)

实施 != 操作员。

在列上下文中，生成子句 a != b . 如果目标是 None 生产 a IS NOT NULL .

method sqlalchemy.sql.expression.ColumnOperators.__neg__()

实施 - 操作员。

在列上下文中，生成子句 -a .

method sqlalchemy.sql.expression.ColumnOperators.__or__(other)

inherited from the sqlalchemy.sql.expression.Operators.__or__ method of Operators

实施 | 操作员。

当与SQL表达式一起使用时，会产生一个或操作，相当于 or_() ，即：

a | b

等于：

from sqlalchemy import or_
or_(a, b)

使用时应小心 | 关于运算符优先级； | 运算符具有最高优先级。如果操作数包含其他子表达式，则应将它们括在括号中：：

(a == 2) | (b == 4)
method sqlalchemy.sql.expression.ColumnOperators.__radd__(other)

实施 + 反向操作。

见 ColumnOperators.__add__() .

method sqlalchemy.sql.expression.ColumnOperators.__rdiv__(other)

实施 / 反向操作。

见 ColumnOperators.__div__() .

method sqlalchemy.sql.expression.ColumnOperators.__rmod__(other)

实施 % 反向操作。

见 ColumnOperators.__mod__() .

method sqlalchemy.sql.expression.ColumnOperators.__rmul__(other)

实施 * 反向操作。

见 ColumnOperators.__mul__() .

method sqlalchemy.sql.expression.ColumnOperators.__rshift__(other)

执行>>操作员。

不由sqlachemy core使用，这是为希望使用>>作为扩展点的自定义操作员系统提供的。

method sqlalchemy.sql.expression.ColumnOperators.__rsub__(other)

实施 - 反向操作。

见 ColumnOperators.__sub__() .

method sqlalchemy.sql.expression.ColumnOperators.__rtruediv__(other)

实施 // 反向操作。

见 ColumnOperators.__truediv__() .

method sqlalchemy.sql.expression.ColumnOperators.__sub__(other)

实施 - 操作员。

在列上下文中，生成子句 a - b .

method sqlalchemy.sql.expression.ColumnOperators.__truediv__(other)

实施 // 操作员。

在列上下文中，生成子句 a / b .

method sqlalchemy.sql.expression.ColumnOperators.all_()

制作一个 all_() 子句对父对象执行操作。

请参阅的文档 all_() 举个例子。

注解

一定不要把新的弄糊涂了 ColumnOperators.all_() 方法及其较旧的 ARRAY -特定的对应方，即 Comparator.all() 方法，该方法使用不同的调用语法和使用模式。

1.1 新版功能.

method sqlalchemy.sql.expression.ColumnOperators.any_()

制作一个 any_() 子句对父对象执行操作。

请参阅的文档 any_() 举个例子。

注解

一定不要把新的弄糊涂了 ColumnOperators.any_() 方法及其较旧的 ARRAY -特定的对应方，即 Comparator.any() 方法，该方法使用不同的调用语法和使用模式。

1.1 新版功能.

method sqlalchemy.sql.expression.ColumnOperators.asc()

产生一个 asc() 针对父对象的子句。

method sqlalchemy.sql.expression.ColumnOperators.between(cleft, cright, symmetric=False)

产生一个 between() 在给定上下限的情况下，针对父对象的子句。

method sqlalchemy.sql.expression.ColumnOperators.bool_op(opstring, precedence=0)

inherited from the Operators.bool_op() method of Operators

返回自定义布尔运算符。

这个方法是调用 Operators.op() 并通过 Operators.op.is_comparison 标记为真。

参见

Operators.op()

method sqlalchemy.sql.expression.ColumnOperators.collate(collation)

产生一个 collate() 在给定排序规则字符串的情况下，对父对象执行子句。

参见

collate()

method sqlalchemy.sql.expression.ColumnOperators.concat(other)

实现“concat”运算符。

在列上下文中，生成子句 a || b 或使用 concat() mysql上的操作符。

method sqlalchemy.sql.expression.ColumnOperators.contains(other, **kwargs)

实现“contains”运算符。

生成一个类似表达式，该表达式根据字符串值中间的匹配项进行测试：

column LIKE '%' || <other> || '%'

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.contains("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值， ColumnOperators.contains.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符，以便它们与自身匹配，而不是作为通配符匹配。或者， ColumnOperators.contains.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是文本字符串时可以使用该字符。

参数

  • other -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.contains.autoescape 标志设置为真。

  • autoescape -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.包含（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param |‘%‘ESCAPE’/”，值为 :param 作为 "foo/%bar" .

  • escape -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.contains（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.contains.autoescape ：：someColumn.contains（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

ColumnOperators.startswith()

ColumnOperators.endswith()

ColumnOperators.like()

method sqlalchemy.sql.expression.ColumnOperators.desc()

产生一个 desc() 针对父对象的子句。

method sqlalchemy.sql.expression.ColumnOperators.distinct()

产生一个 distinct() 针对父对象的子句。

method sqlalchemy.sql.expression.ColumnOperators.endswith(other, **kwargs)

实现“endswith”运算符。

生成一个类似表达式，该表达式根据字符串值末尾的匹配项进行测试：

column LIKE '%' || <other>

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.endswith("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值， ColumnOperators.endswith.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符，以便它们与自身匹配，而不是作为通配符匹配。或者， ColumnOperators.endswith.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是文本字符串时可以使用该字符。

参数

  • other -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.endswith.autoescape 标志设置为真。

  • autoescape -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.endswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param ESCAPE“/”值为 :param 作为 "foo/%bar" .

  • escape -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.endswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param ESCAPE '^' The parameter may also be combined with ColumnOperators.endswith.autoescape ：：someColumn.endsWith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

ColumnOperators.startswith()

ColumnOperators.contains()

ColumnOperators.like()

method sqlalchemy.sql.expression.ColumnOperators.ilike(other, escape=None)

实施 ilike 运算符，例如不区分大小写的like。

在列上下文中，生成以下任一形式的表达式：

lower(a) LIKE lower(other)

或者在支持ilike运算符的后端：

a ILIKE other

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.ilike("%foobar%"))
参数

  • other -- 要比较的表达式

  • escape -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.ilike（“foo/%bar”，escape=“/”）

参见

ColumnOperators.like()

method sqlalchemy.sql.expression.ColumnOperators.in_(other)

实施 in 操作员。

在列上下文中，生成子句 column IN <other> .

给定参数 other 可能是：

  • 文字值列表，例如：

    stmt.where(column.in_([1, 2, 3]))

    在此调用表单中，项目列表将转换为一组与给定列表长度相同的绑定参数：

    WHERE COL IN (?, ?, ?)

  • 如果比较与 tuple_() 包含多个表达式：

    from sqlalchemy import tuple_
stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))

  • 空列表，例如：

    stmt.where(column.in_([]))

    在此调用形式中，表达式呈现“空集”表达式。这些表达式是针对各个后端量身定做的，通常会尝试将空的SELECT语句作为子查询。例如在SQLite上，表达式为：：

    WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

    在 1.4 版更改: 空IN表达式现在在所有情况下都使用生成的SELECT子查询的执行时间。

  • 绑定参数，例如 bindparam() ，如果包含 bindparam.expanding 旗帜：

    stmt.where(column.in_(bindparam('value', expanding=True)))

    在此调用表单中，表达式呈现一个特殊的非SQL占位符表达式，其外观如下：

    WHERE COL IN ([EXPANDING_value])

    此占位符表达式在语句执行时被截取，以便转换为前面所示的绑定参数表单的变量号。如果语句的执行方式为：

    connection.execute(stmt, {"value": [1, 2, 3]})

    将为数据库传递每个值的绑定参数：

    WHERE COL IN (?, ?, ?)

    1.2 新版功能: 添加了“扩展”绑定参数

    如果传递空列表，将呈现一个特定于正在使用的数据库的特殊“空列表”表达式。在sqlite上：

    WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

    1.3 新版功能: “expanding”绑定参数现在支持空列表

  • 一 select() 构造，通常是相关的标量选择：

    stmt.where(
    column.in_(
        select(othertable.c.y).
        where(table.c.x == othertable.c.x)
    )
)

    在这个调用表单中， ColumnOperators.in_() 按给定呈现：

    WHERE COL IN (SELECT othertable.y
FROM othertable WHERE othertable.x = table.x)
参数

other -- 文字列表，a select() 构造，或 bindparam() 构造，包括 bindparam.expanding 标志设置为真。

method sqlalchemy.sql.expression.ColumnOperators.is_(other)

实施 IS 操作员。

通常情况下， IS 与以下值比较时自动生成 None ，决定 NULL . 但是，明确使用 IS 如果与某些平台上的布尔值进行比较，可能是可取的。

参见

ColumnOperators.is_not()

method sqlalchemy.sql.expression.ColumnOperators.is_distinct_from(other)

实施 IS DISTINCT FROM 操作员。

在大多数平台上呈现“a与b不同”；在某些平台上，例如sqlite可能呈现“a不是b”。

1.1 新版功能.

method sqlalchemy.sql.expression.ColumnOperators.is_not(other)

实施 IS NOT 操作员。

通常情况下， IS NOT 与以下值比较时自动生成 None ，决定 NULL . 但是，明确使用 IS NOT 如果与某些平台上的布尔值进行比较，可能是可取的。

在 1.4 版更改: 这个 is_not() 运算符重命名自 isnot() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.is_()

method sqlalchemy.sql.expression.ColumnOperators.is_not_distinct_from(other)

实施 IS NOT DISTINCT FROM 操作员。

在大多数平台上呈现“a与b不同”；在某些平台上，例如sqlite可能呈现“a是b”。

在 1.4 版更改: 这个 is_not_distinct_from() 运算符重命名自 isnot_distinct_from() 在以前的版本中。以前的名称仍然可以向后兼容。

1.1 新版功能.

method sqlalchemy.sql.expression.ColumnOperators.isnot(other)

实施 IS NOT 操作员。

通常情况下， IS NOT 与以下值比较时自动生成 None ，决定 NULL . 但是，明确使用 IS NOT 如果与某些平台上的布尔值进行比较，可能是可取的。

在 1.4 版更改: 这个 is_not() 运算符重命名自 isnot() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.is_()

method sqlalchemy.sql.expression.ColumnOperators.isnot_distinct_from(other)

实施 IS NOT DISTINCT FROM 操作员。

在大多数平台上呈现“a与b不同”；在某些平台上，例如sqlite可能呈现“a是b”。

在 1.4 版更改: 这个 is_not_distinct_from() 运算符重命名自 isnot_distinct_from() 在以前的版本中。以前的名称仍然可以向后兼容。

1.1 新版功能.

method sqlalchemy.sql.expression.ColumnOperators.like(other, escape=None)

实施 like 操作员。

在列上下文中，生成表达式：：

a LIKE other

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.like("%foobar%"))
参数

  • other -- 要比较的表达式

  • escape -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.like（“foo/%bar”，escape=“/”）

参见

ColumnOperators.ilike()

method sqlalchemy.sql.expression.ColumnOperators.match(other, **kwargs)

实现特定于数据库的“match”运算符。

ColumnOperators.match() 尝试解析为后端提供的类似匹配的函数或运算符。示例包括：

  • PostgreSQL-呈现 x @@ to_tsquery(y)

  • MySQL -渲染器 MATCH (x) AGAINST (y IN BOOLEAN MODE)

    参见

    match -具有附加功能的MySQL特定构造。

  • Oracle-呈现 CONTAINS(x, y)

  • 其他后端可能提供特殊的实现。

  • 没有任何特殊实现的后端将发出“match”操作符。例如，这与sqlite兼容。

method sqlalchemy.sql.expression.ColumnOperators.not_ilike(other, escape=None)

实施 NOT ILIKE 操作员。

这相当于使用否定 ColumnOperators.ilike() ，即 ~x.ilike(y) .

在 1.4 版更改: 这个 not_ilike() 运算符重命名自 notilike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.ilike()

method sqlalchemy.sql.expression.ColumnOperators.not_in(other)

实施 NOT IN 操作员。

这相当于使用否定 ColumnOperators.in_() ，即 ~x.in_(y) .

在这种情况下 other 是一个空序列，编译器生成一个“empty not in”表达式。这将默认表达式“1=1”在所有情况下都生成“真”。这个 create_engine.empty_in_strategy 可用于更改此行为。

在 1.4 版更改: 这个 not_in() 运算符重命名自 notin_() 在以前的版本中。以前的名称仍然可以向后兼容。

在 1.2 版更改: 这个 ColumnOperators.in_() 和 ColumnOperators.not_in() 现在，默认情况下，运算符为空序列生成一个“静态”表达式。

参见

ColumnOperators.in_()

method sqlalchemy.sql.expression.ColumnOperators.not_like(other, escape=None)

实施 NOT LIKE 操作员。

这相当于使用否定 ColumnOperators.like() ，即 ~x.like(y) .

在 1.4 版更改: 这个 not_like() 运算符重命名自 notlike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.like()

method sqlalchemy.sql.expression.ColumnOperators.notilike(other, escape=None)

实施 NOT ILIKE 操作员。

这相当于使用否定 ColumnOperators.ilike() ，即 ~x.ilike(y) .

在 1.4 版更改: 这个 not_ilike() 运算符重命名自 notilike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.ilike()

method sqlalchemy.sql.expression.ColumnOperators.notin_(other)

实施 NOT IN 操作员。

这相当于使用否定 ColumnOperators.in_() ，即 ~x.in_(y) .

在这种情况下 other 是一个空序列，编译器生成一个“empty not in”表达式。这将默认表达式“1=1”在所有情况下都生成“真”。这个 create_engine.empty_in_strategy 可用于更改此行为。

在 1.4 版更改: 这个 not_in() 运算符重命名自 notin_() 在以前的版本中。以前的名称仍然可以向后兼容。

在 1.2 版更改: 这个 ColumnOperators.in_() 和 ColumnOperators.not_in() 现在，默认情况下，运算符为空序列生成一个“静态”表达式。

参见

ColumnOperators.in_()

method sqlalchemy.sql.expression.ColumnOperators.notlike(other, escape=None)

实施 NOT LIKE 操作员。

这相当于使用否定 ColumnOperators.like() ，即 ~x.like(y) .

在 1.4 版更改: 这个 not_like() 运算符重命名自 notlike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.like()

method sqlalchemy.sql.expression.ColumnOperators.nulls_first()

产生一个 nulls_first() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_first() 运算符重命名自 nullsfirst() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.sql.expression.ColumnOperators.nulls_last()

产生一个 nulls_last() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_last() 运算符重命名自 nullslast() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.sql.expression.ColumnOperators.nullsfirst()

产生一个 nulls_first() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_first() 运算符重命名自 nullsfirst() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.sql.expression.ColumnOperators.nullslast()

产生一个 nulls_last() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_last() 运算符重命名自 nullslast() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.sql.expression.ColumnOperators.op(opstring, precedence=0, is_comparison=False, return_type=None)

inherited from the Operators.op() method of Operators

生成泛型运算符函数。

例如。：：

somecolumn.op("*")(5)

生产：：

somecolumn * 5

此函数还可用于显式地生成位运算符。例如：：

somecolumn.op('&')(0xff)

是中的值的位与 somecolumn .

参数

  • operator -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。

  • precedence -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时，较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (, ） AS 运算符。值100将大于或等于所有运算符，-100将小于或等于所有运算符。

  • is_comparison -- 如果为真，则该运算符将被视为“比较”运算符，即计算为布尔真/假值，如 == ， > 等等。应设置此标志，以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded:：0.9.2-添加了 Operators.op.is_comparison 旗帜。

  • return_type -- 一 TypeEngine 类或对象，它将强制此运算符生成的表达式的返回类型为该类型。默认情况下，指定 Operators.op.is_comparison 将决心 Boolean ，而那些不属于左侧操作数的类型。

参见

重新定义和创建新的运算符

在联接条件中使用自定义运算符

method sqlalchemy.sql.expression.ColumnOperators.operate(op, *other, **kwargs)

inherited from the Operators.operate() method of Operators

对参数进行运算。

这是最低级别的操作，提升 NotImplementedError 默认情况下。

在子类上覆盖此项可以允许将公共行为应用于所有操作。例如，重写 ColumnOperators 申请 func.lower() 左右两侧：

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数

  • op -- 操作员可调用。

  • *other -- 操作的“另一方”。对于大多数操作，将是单个标量。

  • **kwargs -- 修饰语。这些可由特殊操作员通过，如 ColumnOperators.contains() .

method sqlalchemy.sql.expression.ColumnOperators.regexp_match(pattern, flags=None)

实现特定于数据库的“regexp match”运算符。

例如。：：

stmt = select(table.c.some_column).where(
    table.c.some_column.regexp_match('^(b|c)')
)

ColumnOperators.regexp_match() 尝试解析为后端提供的类似REGEXP的函数或运算符，但是可用的特定正则表达式语法和标志是 不是后端不可知的 .

示例包括：

  • PostgreSQL-呈现 x ~ y 或 x !~ y 当被否定时。

  • Oracle-呈现 REGEXP_LIKE(x, y)

  • SQLite-使用SQLite的 REGEXP 占位符运算符和对Python的调用 re.match() 内置的。

  • 其他后端可能提供特殊的实现。

  • 没有任何特殊实现的后端将发出操作符“REGEXP”或“NOT REGEXP”。例如，这与SQLite和MySQL兼容。

正则表达式支持目前是针对Oracle、PostgreSQL、MySQL和MariaDB实现的。部分支持SQLite。第三方方言之间的支持可能会有所不同。

参数

  • pattern -- 正则表达式模式字符串或列子句。

  • flags -- 要应用的任何正则表达式字符串标志。标志往往是特定于后端的。它可以是字符串或列子句。一些后端，比如PostgreSQL和MariaDB，可以选择将标志指定为模式的一部分。在PostgreSQL中使用ignore case标志“i”时，ignore case regexp match运算符 ~* 或 !~* 将被使用。

1.4 新版功能.

参见

ColumnOperators.regexp_replace()

method sqlalchemy.sql.expression.ColumnOperators.regexp_replace(pattern, replacement, flags=None)

实现特定于数据库的“regexp replace”运算符。

例如。：：

stmt = select(
    table.c.some_column.regexp_replace(
        'b(..)',
        'XY',
        flags='g'
    )
)

ColumnOperators.regexp_replace() 尝试解析为后端提供的类似REGEXP_REPLACE的函数，该函数通常发出该函数 REGEXP_REPLACE() . 但是，可用的特定正则表达式语法和标志是 不是后端不可知的 .

目前已为Oracle、PostgreSQL、MySQL8或更高版本和MariaDB实现正则表达式替换支持。第三方方言之间的支持可能会有所不同。

参数

  • pattern -- 正则表达式模式字符串或列子句。

  • pattern -- 替换字符串或列子句。

  • flags -- 要应用的任何正则表达式字符串标志。标志往往是特定于后端的。它可以是字符串或列子句。一些后端，比如PostgreSQL和MariaDB，可以选择将标志指定为模式的一部分。

1.4 新版功能.

参见

ColumnOperators.regexp_match()

method sqlalchemy.sql.expression.ColumnOperators.reverse_operate(op, other, **kwargs)

inherited from the Operators.reverse_operate() method of Operators

对参数进行反向运算。

用法与 operate() .

method sqlalchemy.sql.expression.ColumnOperators.startswith(other, **kwargs)

实施 startswith 操作员。

生成一个类似表达式，该表达式根据字符串值开头的匹配项进行测试：

column LIKE <other> || '%'

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.startswith("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值， ColumnOperators.startswith.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符，以便它们与自身匹配，而不是作为通配符匹配。或者， ColumnOperators.startswith.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是文本字符串时可以使用该字符。

参数

  • other -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.startswith.autoescape 标志设置为真。

  • autoescape -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.startswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，类似于：param |'%'ESCAPE'/'的值为 :param 作为 "foo/%bar" .

  • escape -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.startswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn-like :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.startswith.autoescape ：：somecolumn.startswith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

ColumnOperators.endswith()

ColumnOperators.contains()

ColumnOperators.like()

attribute sqlalchemy.sql.expression.ColumnOperators.timetuple = None

hack，允许在lhs上比较datetime对象。

class sqlalchemy.sql.base.DialectKWArgs

建立一个类的能力，使其具有带有默认值和构造函数验证的方言特定参数。

这个 DialectKWArgs 与 DefaultDialect.construct_arguments 以方言呈现。

参见

DefaultDialect.construct_arguments

method sqlalchemy.sql.base.DialectKWArgs.classmethod argument_for(dialect_name, argument_name, default)

为此类添加一种新的方言特定关键字参数。

例如。：：

Index.argument_for("mydialect", "length", None)

some_index = Index('a', 'b', mydialect_length=5)

这个 DialectKWArgs.argument_for() 方法是按参数向 DefaultDialect.construct_arguments 字典。此字典提供了各种模式级构造代表方言接受的参数名列表。

新方言通常应同时将此字典指定为方言类的数据成员。临时添加参数名的用例通常用于最终用户代码，该代码也使用自定义编译方案，该方案使用附加参数。

参数

  • dialect_name -- 方言的名称。方言必须可定位，否则 NoSuchModuleError 提高了。方言还必须包括现有的 DefaultDialect.construct_arguments 集合，指示它参与关键字参数验证和默认系统，否则 ArgumentError 提高了。如果方言不包含此集合，则可以代表此方言指定任何关键字参数。包含在sqlAlchemy中的所有方言都包含此集合，但是对于第三方方言，支持可能有所不同。

  • argument_name -- 参数的名称。

  • default -- 参数的默认值。

0.9.4 新版功能.

attribute sqlalchemy.sql.base.DialectKWArgs.dialect_kwargs

指定为此构造的方言特定选项的关键字参数集合。

这些论据以原版呈现在这里。 <dialect>_<kwarg> 格式。只包括实际传递的参数；与 DialectKWArgs.dialect_options 集合，其中包含此方言已知的所有选项，包括默认值。

集合也是可写的；接受窗体的键 <dialect>_<kwarg> 值将组合到选项列表中。

0.9.2 新版功能.

在 0.9.4 版更改: 这个 DialectKWArgs.dialect_kwargs 集合现在可写。

参见

DialectKWArgs.dialect_options -嵌套字典窗体

attribute sqlalchemy.sql.base.DialectKWArgs.dialect_options

指定为此构造的方言特定选项的关键字参数集合。

这是一个两级嵌套注册表，键控为 <dialect_name> 和 <argument_name> . 例如， postgresql_where 参数可定位为：

arg = my_object.dialect_options['postgresql']['where']

0.9.2 新版功能.

参见

DialectKWArgs.dialect_kwargs -平字典形式

attribute sqlalchemy.sql.base.DialectKWArgs.kwargs

同义词 DialectKWArgs.dialect_kwargs .

class sqlalchemy.sql.expression.Extract(field, expr, **kwargs)

表示一个SQL提取子句， extract(field FROM expr) .

类签名

class sqlalchemy.sql.expression.Extract (sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.Extract.__init__(field, expr, **kwargs)

构建新的 Extract 对象。

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

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

代表 false SQL语句中的关键字或等效项。

False_ 作为常量通过 false() 功能。

类签名

class sqlalchemy.sql.expression.False_ (sqlalchemy.sql.expression.SingletonConstant, sqlalchemy.sql.roles.ConstExprRole, sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.sql.expression.FunctionFilter(func, *criterion)

表示一个函数筛选子句。

这是一个针对聚合和窗口函数的特殊运算符，它控制传递给它的行。只有某些数据库后端支持它。

调用 FunctionFilter 是通过 FunctionElement.filter() ：：

func.count(1).filter(True)

1.0.0 新版功能.

参见

FunctionElement.filter()

类签名

class sqlalchemy.sql.expression.FunctionFilter (sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.FunctionFilter.__init__(func, *criterion)

构建新的 FunctionFilter 对象。

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

method sqlalchemy.sql.expression.FunctionFilter.filter(*criterion)

针对函数生成一个额外的过滤器。

此方法将附加条件添加到 FunctionElement.filter() .

在SQL呈现时，多个条件通过 AND .

method sqlalchemy.sql.expression.FunctionFilter.over(partition_by=None, order_by=None, range_=None, rows=None)

针对此筛选函数生成over子句。

用于聚合或所谓的“窗口”函数，用于支持窗口函数的数据库后端。

表达式：

func.rank().filter(MyClass.y > 5).over(order_by='x')

缩写为：

from sqlalchemy import over, funcfilter
over(funcfilter(func.rank(), MyClass.y > 5), order_by='x')

见 over() 完整描述。

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

对此应用“分组” ClauseElement .

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

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

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

class sqlalchemy.sql.expression.Label(name, element, type_=None)

表示列标签（as）。

表示一个标签，通常应用于任何列级元素，使用 AS SQL关键字。

类签名

class sqlalchemy.sql.expression.Label (sqlalchemy.sql.roles.LabeledColumnExprRole, sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.Label.__init__(name, element, type_=None)

构建新的 Label 对象。

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

attribute sqlalchemy.sql.expression.Label.foreign_keys
attribute sqlalchemy.sql.expression.Label.primary_key
method sqlalchemy.sql.expression.Label.self_group(against=None)

对此应用“分组” ClauseElement .

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

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

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

class sqlalchemy.sql.expression.LambdaElement(fn, role, opts=<class 'sqlalchemy.sql.lambdas.LambdaOptions'>, apply_propagate_attrs=None)

一个SQL构造，其中状态存储为未调用的lambda。

这个 LambdaElement 在将lambda表达式传递到SQL构造时透明地生成，例如：

stmt = select(table).where(lambda: table.c.col == parameter)

这个 LambdaElement 是 StatementLambdaElement 它表示lambda中的完整语句。

1.4 新版功能.

参见

使用Lambdas为语句生成添加显著的速度增益

类签名

class sqlalchemy.sql.expression.LambdaElement (sqlalchemy.sql.expression.ClauseElement)

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

表示SQL语句中的空关键字。

Null 作为常量通过 null() 功能。

类签名

class sqlalchemy.sql.expression.Null (sqlalchemy.sql.expression.SingletonConstant, sqlalchemy.sql.roles.ConstExprRole, sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.sql.expression.Operators

比较和逻辑运算符的基础。

实现基方法 Operators.operate() 和 Operators.reverse_operate() 以及 Operators.__and__() ， Operators.__or__() ， Operators.__invert__() .

通常通过其最常见的子类使用 ColumnOperators .

method sqlalchemy.sql.expression.Operators.__and__(other)

实施 & 操作员。

当与SQL表达式一起使用时，将生成一个和操作，相当于 and_() ，即：

a & b

等于：

from sqlalchemy import and_
and_(a, b)

使用时应小心 & 关于运算符优先级； & 运算符具有最高优先级。如果操作数包含其他子表达式，则应将它们括在括号中：：

(a == 2) & (b == 4)
method sqlalchemy.sql.expression.Operators.__invert__()

实施 ~ 操作员。

当与SQL表达式一起使用时，会导致一个非操作，相当于 not_() ，即：

~a

等于：

from sqlalchemy import not_
not_(a)
method sqlalchemy.sql.expression.Operators.__or__(other)

实施 | 操作员。

当与SQL表达式一起使用时，会产生一个或操作，相当于 or_() ，即：

a | b

等于：

from sqlalchemy import or_
or_(a, b)

使用时应小心 | 关于运算符优先级； | 运算符具有最高优先级。如果操作数包含其他子表达式，则应将它们括在括号中：：

(a == 2) | (b == 4)
method sqlalchemy.sql.expression.Operators.bool_op(opstring, precedence=0)

返回自定义布尔运算符。

这个方法是调用 Operators.op() 并通过 Operators.op.is_comparison 标记为真。

参见

Operators.op()

method sqlalchemy.sql.expression.Operators.op(opstring, precedence=0, is_comparison=False, return_type=None)

生成泛型运算符函数。

例如。：：

somecolumn.op("*")(5)

生产：：

somecolumn * 5

此函数还可用于显式地生成位运算符。例如：：

somecolumn.op('&')(0xff)

是中的值的位与 somecolumn .

参数

  • operator -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。

  • precedence -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时，较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (, ） AS 运算符。值100将大于或等于所有运算符，-100将小于或等于所有运算符。

  • is_comparison -- 如果为真，则该运算符将被视为“比较”运算符，即计算为布尔真/假值，如 == ， > 等等。应设置此标志，以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded:：0.9.2-添加了 Operators.op.is_comparison 旗帜。

  • return_type -- 一 TypeEngine 类或对象，它将强制此运算符生成的表达式的返回类型为该类型。默认情况下，指定 Operators.op.is_comparison 将决心 Boolean ，而那些不属于左侧操作数的类型。

参见

重新定义和创建新的运算符

在联接条件中使用自定义运算符

method sqlalchemy.sql.expression.Operators.operate(op, *other, **kwargs)

对参数进行运算。

这是最低级别的操作，提升 NotImplementedError 默认情况下。

在子类上覆盖此项可以允许将公共行为应用于所有操作。例如，重写 ColumnOperators 申请 func.lower() 左右两侧：

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数

  • op -- 操作员可调用。

  • *other -- 操作的“另一方”。对于大多数操作，将是单个标量。

  • **kwargs -- 修饰语。这些可由特殊操作员通过，如 ColumnOperators.contains() .

method sqlalchemy.sql.expression.Operators.reverse_operate(op, other, **kwargs)

对参数进行反向运算。

用法与 operate() .

class sqlalchemy.sql.expression.Over(element, partition_by=None, order_by=None, range_=None, rows=None)

表示一个over子句。

这是针对所谓的“窗口”函数以及任何聚合函数的特殊运算符，它相对于结果集本身产生结果。大多数现代SQL后端现在都支持窗口函数。

类签名

class sqlalchemy.sql.expression.Over (sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.Over.__init__(element, partition_by=None, order_by=None, range_=None, rows=None)

构建新的 Over 对象。

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

attribute sqlalchemy.sql.expression.Over.element = None

此对象的基础表达式对象 Over 对象指向。

class sqlalchemy.sql.expression.StatementLambdaElement(fn, role, opts=<class 'sqlalchemy.sql.lambdas.LambdaOptions'>, apply_propagate_attrs=None)

将可组合的SQL语句表示为 LambdaElement .

这个 StatementLambdaElement 是使用 lambda_stmt() 功能：

from sqlalchemy import lambda_stmt

stmt = lambda_stmt(lambda: select(table))

构造完成后，可以通过添加后续lambda在语句中构建附加条件，lambda接受现有语句对象作为单个参数：：

stmt += lambda s: s.where(table.c.col == parameter)

1.4 新版功能.

参见

使用Lambdas为语句生成添加显著的速度增益

类签名

class sqlalchemy.sql.expression.StatementLambdaElement (sqlalchemy.sql.roles.AllowsLambdaRole, sqlalchemy.sql.lambdas.LambdaElement)

method sqlalchemy.sql.expression.StatementLambdaElement.add_criteria(other, enable_tracking=True, track_on=None, track_closure_variables=True, track_bound_values=True)

向此添加新条件 StatementLambdaElement 。

例如。：：

>>> def my_stmt(parameter):
...     stmt = lambda_stmt(
...         lambda: select(table.c.x, table.c.y),
...     )
...     stmt = stmt.add_criteria(
...         lambda: table.c.x > parameter
...     )
...     return stmt

这个 StatementLambdaElement.add_criteria() 方法等效于使用Python加运算符添加新的lambda，不同之处在于可以添加其他参数，包括 track_closure_values 和 track_on ：：

>>> def my_stmt(self, foo):
...     stmt = lambda_stmt(
...         lambda: select(func.max(foo.x, foo.y)),
...         track_closure_variables=False
...     )
...     stmt = stmt.add_criteria(
...         lambda: self.where_criteria,
...         track_on=[self]
...     )
...     return stmt

看见 lambda_stmt() 有关接受的参数的说明，请参见。

method sqlalchemy.sql.expression.StatementLambdaElement.spoil()

返回一个新的 StatementLambdaElement 每次都会无条件地运行所有lambda。

class sqlalchemy.sql.expression.TextClause(text, bind=None)

表示文字SQL文本片段。

例如。：：

from sqlalchemy import text

t = text("SELECT * FROM users")
result = connection.execute(t)

这个 TextClause 构造是使用 text() 函数；有关完整文档，请参见该函数。

参见

text()

类签名

class sqlalchemy.sql.expression.TextClause (sqlalchemy.sql.roles.DDLConstraintColumnRole, sqlalchemy.sql.roles.DDLExpressionRole, sqlalchemy.sql.roles.StatementOptionRole, sqlalchemy.sql.roles.WhereHavingRole, sqlalchemy.sql.roles.OrderByRole, sqlalchemy.sql.roles.FromClauseRole, sqlalchemy.sql.roles.SelectStatementRole, sqlalchemy.sql.roles.BinaryElementRole, sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.expression.Executable, sqlalchemy.sql.expression.ClauseElement)

method sqlalchemy.sql.expression.TextClause.bindparams(*binds, **names_to_values)

在此范围内建立绑定参数的值和/或类型 TextClause 构造。

给定文本结构，例如：

from sqlalchemy import text
stmt = text("SELECT id, name FROM user WHERE name=:name "
            "AND timestamp=:timestamp")

这个 TextClause.bindparams() 方法可用于确定 :name 和 :timestamp ，使用简单关键字参数：：

stmt = stmt.bindparams(name='jack',
            timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5))

在上面，新的 BindParameter 将使用名称生成对象 name 和 timestamp 和值 jack 和 datetime.datetime(2012, 10, 8, 15, 12, 5) ，分别。在这种情况下，将根据给定的值推断类型 String 和 DateTime .

当需要特定的类型行为时，位置 *binds 参数不能用于指定 bindparam() 直接构造。这些构造必须至少包括 key 参数，然后是可选值和类型：：

from sqlalchemy import bindparam
stmt = stmt.bindparams(
                bindparam('name', value='jack', type_=String),
                bindparam('timestamp', type_=DateTime)
            )

上面，我们指定了 DateTime 对于 timestamp 绑定，以及 String 对于 name 绑定。在情况下 name 我们还设置了默认值 "jack" .

可以在语句执行时提供其他绑定参数，例如：

result = connection.execute(stmt,
            timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5))

这个 TextClause.bindparams() 方法可以重复调用，它将在其中重新使用现有的 BindParameter 对象以添加新信息。例如，我们可以调用 TextClause.bindparams() 第一次输入信息，第二次输入值信息，并将其组合：

stmt = text("SELECT id, name FROM user WHERE name=:name "
            "AND timestamp=:timestamp")
stmt = stmt.bindparams(
    bindparam('name', type_=String),
    bindparam('timestamp', type_=DateTime)
)
stmt = stmt.bindparams(
    name='jack',
    timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5)
)

这个 TextClause.bindparams() 方法还支持 独特的 绑定参数。这些是在语句编译时对名称“未验证”的参数，因此 text() 构造可以组合在一起，而不会出现名称冲突。要使用此功能，请指定 BindParameter.unique 在每个 bindparam() 对象：

stmt1 = text("select id from table where name=:name").bindparams(
    bindparam("name", value='name1', unique=True)
)
stmt2 = text("select id from table where name=:name").bindparams(
    bindparam("name", value='name2', unique=True)
)

union = union_all(
    stmt1.columns(column("id")),
    stmt2.columns(column("id"))
)

上述语句将呈现为：

select id from table where name=:name_1
UNION ALL select id from table where name=:name_2

1.3.11 新版功能: 增加了对 BindParameter.unique 要使用的标志 text() 构造。

method sqlalchemy.sql.expression.TextClause.columns(*cols, **types)

打开这个 TextClause 对象变成 TextualSelect 与select语句具有相同角色的对象。

这个 TextualSelect 是 SelectBase 并且可以通过使用 TextualSelect.subquery() 生成的方法 Subquery 对象，然后可以从中选择。

此函数基本上弥合了纯文本select语句与“selectable”的SQL表达式语言概念之间的差距：

from sqlalchemy.sql import column, text

stmt = text("SELECT id, name FROM some_table")
stmt = stmt.columns(column('id'), column('name')).subquery('st')

stmt = select(mytable).\
        select_from(
            mytable.join(stmt, mytable.c.name == stmt.c.name)
        ).where(stmt.c.id > 5)

上面，我们通过了一系列 column() 元素到 TextClause.columns() 方法位置。这些 column() 元素现在成为第一类元素 TextualSelect.selected_columns 列集合，然后成为 Subquery.c 之后收集 TextualSelect.subquery() 被调用。

我们传递给的列表达式 TextClause.columns() 也可以打印；当我们这样做时，这些 TypeEngine 对象成为列的有效返回类型，因此可以对返回值使用SQLAlchemy的结果集处理系统。这对于日期或布尔类型等类型以及某些方言配置上的Unicode处理通常是必需的：

stmt = text("SELECT id, name, timestamp FROM some_table")
stmt = stmt.columns(
            column('id', Integer),
            column('name', Unicode),
            column('timestamp', DateTime)
        )

for id, name, timestamp in connection.execute(stmt):
    print(id, name, timestamp)

作为上述语法的快捷方式，如果只需要类型转换，则可以使用单独引用类型的关键字参数：：

stmt = text("SELECT id, name, timestamp FROM some_table")
stmt = stmt.columns(
            id=Integer,
            name=Unicode,
            timestamp=DateTime
        )

for id, name, timestamp in connection.execute(stmt):
    print(id, name, timestamp)

位置形式 TextClause.columns() 还提供了 位置列目标 这在将ORM用于复杂的文本查询时特别有用。如果我们将模型中的列指定为 TextClause.columns() ，结果集将按位置与这些列匹配，这意味着文本SQL中列的名称或原点无关紧要：

stmt = text("SELECT users.id, addresses.id, users.id, "
     "users.name, addresses.email_address AS email "
     "FROM users JOIN addresses ON users.id=addresses.user_id "
     "WHERE users.id = 1").columns(
        User.id,
        Address.id,
        Address.user_id,
        User.name,
        Address.email_address
     )

query = session.query(User).from_statement(stmt).options(
    contains_eager(User.addresses))

1.1 新版功能: 这个 TextClause.columns() 当列表达式以纯位置方式传递时，方法现在在结果集中提供位置列目标。

这个 TextClause.columns() 方法提供调用的直接路由 FromClause.subquery() 以及 SelectBase.cte() 对照文本select语句：

stmt = stmt.columns(id=Integer, name=String).cte('st')

stmt = select(sometable).where(sometable.c.id == stmt.c.id)
参数

  • *cols -- 一系列 ColumnElement 对象，通常 Column 对象来自 Table 或ORM级别的列映射属性，表示此文本字符串将从中选择的一组列。

  • **types -- 字符串名称映射到 TypeEngine 键入对象，指示要用于从文本字符串中选择的名称的数据类型。喜欢使用 *cols 参数，因为它还指示位置顺序。

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

对此应用“分组” ClauseElement .

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

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

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

class sqlalchemy.sql.expression.Tuple(*clauses, **kw)

表示SQL元组。

类签名

class sqlalchemy.sql.expression.Tuple (sqlalchemy.sql.expression.ClauseList, sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.Tuple.__init__(*clauses, **kw)

构建新的 Tuple 对象。

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

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

对此应用“分组” ClauseElement .

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

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

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

class sqlalchemy.sql.expression.WithinGroup(element, *order_by)

表示组内（order by）子句。

这是针对所谓的“有序集聚合”和“假设集聚合”函数的特殊运算符，包括 percentile_cont() ， rank() ， dense_rank() 等。

它只受某些数据库后端支持，如PostgreSQL、Oracle和MS SQL Server。

这个 WithinGroup 构造从方法中提取其类型 FunctionElement.within_group_type() . 如果这种回报 None ，函数的 .type 使用。

类签名

class sqlalchemy.sql.expression.WithinGroup (sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.WithinGroup.__init__(element, *order_by)

构建新的 WithinGroup 对象。

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

method sqlalchemy.sql.expression.WithinGroup.over(partition_by=None, order_by=None, range_=None, rows=None)

针对此生成一个over子句 WithinGroup 构造。

此函数与的签名相同 FunctionElement.over() .

class sqlalchemy.sql.elements.WrapsColumnExpression

定义一个 ColumnElement 作为对已具有名称的表达式具有特殊标记行为的包装器。

1.4 新版功能.

参见

使用CAST或类似方法改进了简单列表达式的列标记

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

代表 true SQL语句中的关键字或等效项。

True_ 作为常量通过 true() 功能。

类签名

class sqlalchemy.sql.expression.True_ (sqlalchemy.sql.expression.SingletonConstant, sqlalchemy.sql.roles.ConstExprRole, sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.sql.expression.TypeCoerce(expression, type_)

表示Python端类型强制包装。

TypeCoerce 供应 type_coerce() 函数；有关用法的详细信息，请参阅该函数。

在 1.1 版更改: 这个 type_coerce() 函数现在产生一个持久的 TypeCoerce 包装对象而不是就地转换给定对象。

参见

type_coerce()

cast()

类签名

class sqlalchemy.sql.expression.TypeCoerce (sqlalchemy.sql.expression.WrapsColumnExpression, sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.TypeCoerce.__init__(expression, type_)

构建新的 TypeCoerce 对象。

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

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

对此应用“分组” ClauseElement .

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

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

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

class sqlalchemy.sql.expression.UnaryExpression(element, operator=None, modifier=None, type_=None, wraps_column_expression=False)

定义“一元”表达式。

一元表达式有一个单列表达式和一个运算符。运算符可以放在列表达式的左侧（在这里称为“operator”）或右侧（在这里称为“modifier”）。

UnaryExpression 是几个一元运算符的基础，包括 desc() ， asc() ， distinct() ， nulls_first() 和 nulls_last() .

类签名

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

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

对此应用“分组” ClauseElement .

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

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

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

免责声明： 以上内容版权归原作者所有，如有侵犯您的原创版权请告知，我们将尽快删除相关内容。感谢每一位辛勤著写的作者，感谢每一位的分享。
@小牛知识库 xnip.cn