列元素和表达式¶

try_cast（） - CAST 的替代方法，当强制转换失败时导致 NULL，而不是引发错误。仅受某些方言支持。

type_coerce（） - CAST 的替代方案，仅在 Python 端强制类型，这通常足以生成正确的 SQL 和数据强制。

函数 sqlalchemy.sql.expression 中。column（text： str， type_：_TypeEngineArgument[_T]None=None， is_literal： bool = False， _selectable：FromClauseNone=None）→ ColumnClause[_T]¶

生成 ColumnClause 对象。

ColumnClause 是 Column 类。column（） function 可以仅使用 name 调用，如下所示：

from sqlalchemy import column

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

上述语句将生成如下 SQL：

SELECT id, name FROM user

构造完成后，column（） 可以像任何其他 SQL 一样使用 expression 元素，例如 select （） 中构建：

from sqlalchemy.sql import column

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

由 column（） 处理的文本假定已处理例如数据库列的名称;如果字符串包含大小写混合，则特殊字符，或匹配目标上的已知保留字 backend 时，列表达式将使用引用由后端确定的行为。生成文本 SQL 表达式，该表达式完全在没有任何引用的情况下呈现，请改用 literal_column（） ，或将 True 作为 column.is_literal 的值传递。此外，完整的 SQL 语句最好使用 text（） 来处理构建。

column（） 可以通过将其与 table（） 函数（这是 Table 的轻量级类似物）结合使用，以类似 table 的方式使用）生成具有最少样板的工作表结构：

from sqlalchemy import table, column, select

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

stmt = select(user.c.description).where(user.c.name == "wendy")

一个 column（） / table（） 如图所示的结构 above 可以在 ad hoc 时尚，并且不与任何 MetaData、DDL 或事件，与其 Table 对应项。

参数

text¶ —— 元素的文本。
type¶- TypeEngine 对象，可以将这个 ColumnClause 和一个类型关联起来。
is_literal¶ – 如果为 True，则假定 ColumnClause 为是一个精确表达式，将传送到输出中，没有无论区分大小写的设置如何，都应用引号规则。这 literal_column（） 函数实质上调用 column（） 时传递 is_literal=True。

另请参阅

类 sqlalchemy.sql.expression 中。custom_op¶

表示 'custom' 运算符。

custom_op 通常在 Operators.op（） 或 Operators.bool_op（） 方法用于创建自定义可调用运算符。在以编程方式构造表达式时，也可以直接使用该类。例如，要表示 “factorial”作：

from sqlalchemy.sql import UnaryExpression
from sqlalchemy.sql import operators
from sqlalchemy import Numeric

unary = UnaryExpression(
    table.c.somecolumn, modifier=operators.custom_op("!"), type_=Numeric
)

另请参阅

ColumnElement.distinct（）

类签名

class sqlalchemy.sql.expression.custom_op （ sqlalchemy.sql.expression.OperatorType ， typing.通用）

函数 sqlalchemy.sql.expression 中。distinct（expr： _ColumnExpressionArgument[_T]）→ 一元表达式[_T]¶

生成列表达式级一元 DISTINCT 子句。

这会将 DISTINCT 关键字应用于单个列 expression（例如，不是整个语句），并专门渲染在那个列位置;这用于 aggregate 函数中的包含，如下所示：

from sqlalchemy import distinct, func

stmt = select(users_table.c.id, func.count(distinct(users_table.c.name)))

上述作将产生类似于以下内容的语句：

SELECT user.id, count(DISTINCT user.name) FROM user

提示

distinct（） 函数不会将 DISTINCT 应用于完整的 SELECT 语句，而是将 DISTINCT 修饰符应用于单个列表达式。对于常规 SELECT DISTINCT support 中，请使用 Select.distinct（） 方法。

distinct（） 函数也可以作为列级方法使用，例如 ColumnElement.distinct（），如下所示：

stmt = select(func.count(users_table.c.name.distinct()))

distinct（） 运算符与 Select.distinct（） 方法 Select，它生成一个 SELECT 语句，其中 DISTINCT 作为一个整体应用于结果集，例如 SELECT DISTINCT 表达式。有关更多信息，请参阅该方法。

另请参阅

Select.distinct（）

函数

函数 sqlalchemy.sql.expression 中。extract（field： str， expr： _ColumnExpressionArgument[Any]）→ 提取¶

返回 Extract 构造。

这通常以 extract（） 的形式提供以及 func.extract 从 func 命名空间。

参数

字段¶ –

要提取的字段。

警告

此字段用作文本 SQL 字符串。 不要将不受信任的输入传递给此字符串。
expr¶– 用作 EXTRACT 表达式右侧的列或 Python 标量表达式。

例如：

from sqlalchemy import extract
from sqlalchemy import table, column

logged_table = table(
    "user",
    column("id"),
    column("date_created"),
)

stmt = select(logged_table.c.id).where(
    extract("YEAR", logged_table.c.date_created) == 2021
)

在上面的示例中，该语句用于从数据库中选择 ID 其中 YEAR 组件与特定值匹配。

同样，也可以选择提取的零部件：

stmt = select(extract("YEAR", logged_table.c.date_created)).where(
    logged_table.c.id == 1
)

EXTRACT 的实现可能因数据库后端而异。提醒用户查阅他们的数据库文档。

函数 sqlalchemy.sql.expression 中。false（）→ False_¶

返回 False_ 构造。

例如：

>>> fromsqlalchemyimportfalse>>> print(select(t.c.x).where(false()))SELECT x FROM t WHERE false

不支持 true/false 常量的后端将呈现为针对 1 或 0 的表达式：

>>> print(select(t.c.x).where(false()))SELECT x FROM t WHERE 0 = 1

true（） 和 false（） 常量在 and_（） 或 or_（） 中还具有 “短路”作连接：

>>> print(select(t.c.x).where(or_(t.c.x>5,true())))SELECT x FROM t WHERE true
>>> print(select(t.c.x).where(and_(t.c.x>5,false())))SELECT x FROM t WHERE false

另请参阅

真（）

sqlalchemy.sql.expression 中。func = <sqlalchemy.sql.functions._FunctionGenerator 对象>¶

生成 SQL 函数表达式。

func 是一个特殊的对象实例，它根据基于名称的属性生成 SQL 函数，例如：

>>> print(func.count(1))count(:param_1)

返回的对象是 Function 的实例，并且与其他任何元素一样是面向列的 SQL 元素，并以这种方式使用：

>>> print(select(func.count(table.c.id)))SELECT count(sometable.id) FROM sometable

可以为 func 指定任何名称。如果 SQLAlchemy 不知道函数名称，它将完全按原样呈现。对于 SQLAlchemy 知道的常见 SQL 函数，该名称可以解释为泛型函数，该函数将被适当地编译到目标数据库：

>>> print(func.current_timestamp())CURRENT_TIMESTAMP

要调用存在于点分隔包中的函数，请以相同的方式指定它们：

>>> print(func.stats.yield_curve(5,10))stats.yield_curve(:yield_curve_1, :yield_curve_2)

SQLAlchemy 可以知道要启用的函数的返回类型特定于类型的词法和基于结果的行为。例如，为了确保基于字符串的函数返回 Unicode 值，并且类似地在表达式中被视为字符串，则指定 Unicode 作为类型：

>>> print(...     func.my_string("hi", type_=Unicode)...     + " "...     + func.my_string("there", type_=Unicode)... )my_string(:my_string_1) || :my_string_2 || my_string(:my_string_3)

func 调用返回的对象通常是 功能。该对象满足 “column” 接口，包括比较和标注功能。该对象还可以传递 Connectable.execute（） 方法，它将首先包装在 SELECT 语句中：

print(connection.execute(func.current_timestamp()).scalar())

在少数例外情况下，func 访问器会将名称重定向到内置表达式，例如 cast（） 或 extract（），因为这些名称具有众所周知的含义，但从 SQLAlchemy 的角度来看，它们与“函数”并不完全相同。

被解释为 “generic” 函数的函数知道如何自动计算其返回类型。有关已知泛型函数的列表，请参阅 SQL 和泛型函数。

注意

func 构造对调用独立“存储过程”的支持有限，尤其是那些具有特殊参数化问题的过程。

有关如何将 DBAPI 级别的 callproc（） 方法用于完全传统的存储过程的详细信息，请参阅调用存储过程和用户定义的函数部分。

另请参阅

使用 SQL 函数 - 在 SQLAlchemy Unified 教程中

功能

函数 sqlalchemy.sql.expression 中。lambda_stmt（lmb： Callable[[]， Any]， enable_tracking： bool = True、track_closure_variables：bool = True、track_on：objectNone=None、global_track_bound_values：bool = True、track_bound_values： bool = True， lambda_cache：MutableMapping[Tuple[Any,...]，NonAnalyzedFunctionAnalyzedFunction]None=None）→ StatementLambdaElement¶

生成缓存为 lambda 的 SQL 语句。

扫描 lambda 中的 Python 代码对象，以查找将成为绑定参数的 Python 文字，以及引用可能不同的 Core 或 ORM 构造的闭包变量。对于检测到的一组特定构造，lambda 本身将仅调用一次。

例如：

from sqlalchemy import lambda_stmt

stmt = lambda_stmt(lambda: table.select())
stmt += lambda s: s.where(table.c.id == 5)

result = connection.execute(stmt)

返回的对象是 StatementLambdaElement 的实例。

在 1.4 版本加入.

参数

lmb¶– 一个 Python 函数，通常是 lambda，它不接受任何参数并返回一个 SQL 表达式结构
enable_tracking¶– 当 False 时，将禁用对给定 lambda 的所有扫描以查找闭包变量或绑定参数的更改。用于在所有情况下生成相同结果且无参数化的 lambda。
track_closure_variables¶ – 当 False 时，将不会扫描 lambda 中闭包变量的更改。用于 lambda，其中其闭包变量的状态永远不会更改 lambda 返回的 SQL 结构。
track_bound_values¶ – 当 False 时，将为给定的 lambda 禁用绑定参数跟踪。用于不生成任何绑定值或初始绑定值永不更改的 lambda。
global_track_bound_values¶ – 当 False 时，将对整个语句禁用绑定参数跟踪，包括通过 StatementLambdaElement.add_criteria() 该方法添加的其他链接。
lambda_cache¶– 一个字典或其他类似映射的对象，其中将存储有关 lambda 的 Python 代码以及 lambda 本身中跟踪的闭包变量的信息。默认为全局 LRU 缓存。此缓存独立于 Connection 对象使用的 “compiled_cache”。

另请参阅

使用 Lambda 显著提高语句生产速度

函数 sqlalchemy.sql.expression 中。literal（value： Any， type_：_TypeEngineArgument[Any]None=None， literal_execute： bool = False）→ BindParameter[Any]¶

返回绑定到 bind 参数的 Literal 子句。

Literal 子句在非 ClauseElement 对象（例如字符串、整数、日期等）用于与 ColumnElement 的比较作亚纲例如 Column 对象。使用此功能强制生成一个 Literal 子句，该子句将被创建为 BindParameter 替换为绑定值。

参数

value¶ —— 要绑定的值。可以是底层 DB-API 支持的任何 Python 对象，也可以是可通过给定类型参数转换的 Python 对象。
type_¶ —— 一个可选的 TypeEngine，它将为此文字提供 bind-parameter 翻译。
literal_execute¶ –

optional bool，当为 True 时，SQL 引擎将尝试在执行时直接在 SQL 语句中呈现绑定值，而不是作为参数值提供。

2.0 版的新Function。

函数 sqlalchemy.sql.expression 中。literal_column（text： str， type_：_TypeEngineArgument[_T]None=None）→ ColumnClause[_T]¶

生成一个 ColumnClause 对象，该对象具有 column.is_literal 标志设置为 True。

literal_column（） 类似于 column（）的表达式，不同之处在于它更常用作完全按所述方式呈现的“独立”列表达式;while 列（） 存储一个字符串名称，该将被假定为表格的一部分，并可能被引用为表格的一部分， literal_column（） 可以是 that，也可以是任何其他任意的面向列的表达式。

参数

text¶ – 表达式的文本;可以是任何 SQL 表达式。引用规则将不适用。要指定应受引用规则约束的列名表达式，请使用 column（） 功能。
type_¶– 可选的 TypeEngine 对象，它将提供结果集翻译和其他表达式语义这个专栏。如果保留为 None，则类型将为 NullType。

另请参阅

列（）

文本（）

使用文本列表达式进行选择

函数 sqlalchemy.sql.expression 中。not_（子句： _ColumnExpressionArgument[_T]）→ ColumnElement[_T]¶

返回给定子句的否定，即 NOT（clause）。

~ 运算符也会在所有 ColumnElement 子类来生成相同的结果。

函数 sqlalchemy.sql.expression 中。null（）→ 空¶: 返回一个常量 Null 构造。

函数 sqlalchemy.sql.expression 中。or_（*子句）¶

生成由 OR 连接的表达式的联合。

例如：

from sqlalchemy import or_

stmt = select(users_table).where(
    or_(users_table.c.name == "wendy", users_table.c.name == "jack")
)

也可以使用 Python | 运算符使用 or_（） 连接（但请注意，复合表达式需要用括号括起来才能与 Python 运算符优先行为一起使用）：

stmt = select(users_table).where(
    (users_table.c.name == "wendy") | (users_table.c.name == "jack")
)

必须为 or_（） 结构提供至少一个位置参数才能有效;没有参数的 or_（） 结构是模棱两可的。要生成一个 “空” 或动态生成的 or_（） 表达式，从给定的表达式列表中，应该指定 false（） 的 “default” 元素（或只是 False）：

from sqlalchemy import false

or_criteria = or_(false(), *expressions)

上面的表达式将编译为 SQL，表达式为 false 或 0 = 1，具体取决于后端（如果不存在其他表达式）。如果存在表达式，则忽略 false（） 值，因为它不会影响具有其他元素的 OR 表达式的结果。

1.4 版后已移除： or_（） 元素现在要求至少传递一个参数;创建不带参数的 or_（） 构造已被弃用，并且会在继续生成空白 SQL 字符串的同时发出弃用警告。

另请参阅

and_（）

函数 sqlalchemy.sql.expression 中。outparam（key： str， type_：TypeEngine[_T]None=None）→ BindParameter[_T]¶

为支持它们的数据库创建一个 'OUT' 参数，用于函数（存储过程）。

outparam 可以像常规函数参数一样使用。 “output” 值将从 CursorResult 对象通过其 out_parameters 属性，该属性返回包含值的字典。

函数 sqlalchemy.sql.expression 中。text（text： str）→ 文本子句¶

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

例如：

from sqlalchemy import text

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

优势 text（） provides 在纯字符串上是对 Bind 参数的后端中立支持，每个语句执行选项，以及 bind 参数和结果列类型行为，允许 SQLAlchemy 类型结构在执行时发挥作用按字面意思指定的语句。该构造体还可以提供列元素的 .c 集合，允许它作为子查询嵌入到其他 SQL 表达式构造中。

绑定参数由 name 指定，格式为 ：name。例如：

t = text("SELECT * FROM users WHERE id=:user_id")
result = connection.execute(t, {"user_id": 12})

对于需要逐字使用冒号的 SQL 语句，如在内联字符串中，请使用反斜杠进行转义：

t = text(r"SELECT * FROM users WHERE name='\:username'")

TextClause construct 包含的方法可以提供有关 Bound Parameters 和 the column 的信息值，假设它是一个可执行的 SELECT 类型的语句。这 TextClause.bindparams（） method 用于提供 Bound parameter detail 和 TextClause.columns（） 方法允许返回列的规范，包括名称和类型：

t = (
    text("SELECT * FROM users WHERE id=:user_id")
    .bindparams(user_id=7)
    .columns(id=Integer, name=String)
)

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

text（） 构造用于将文本字符串 SQL 片段指定为较大查询的一部分的情况，例如对于 SELECT 语句的 WHERE 子句：

s = select(users.c.id, users.c.name).where(text("id=:user_id"))
result = connection.execute(s, {"user_id": 12})

text（） 还用于使用纯文本构建完整的独立语句。因此，SQLAlchemy 将其称为 Executable 对象，并且可以像传递给 .execute（） 方法的任何其他语句一样使用。

参数

文本¶ –

要创建的 SQL 语句的文本。使用 ：<param> 指定绑定参数;它们将被编译为它们的特定于引擎的格式。

警告

text（） 的 text.text 参数可以作为 Python 字符串参数传递，该参数将被视为受信任的 SQL 文本并按给定方式呈现。不要将不受信任的输入传递给此参数。

另请参阅

使用文本列表达式进行选择

函数 sqlalchemy.sql.expression 中。true（）→ True_¶

返回常量 True_ 构造。

例如：

>>> fromsqlalchemyimporttrue>>> print(select(t.c.x).where(true()))SELECT x FROM t WHERE true

不支持 true/false 常量的后端将呈现为针对 1 或 0 的表达式：

>>> print(select(t.c.x).where(true()))SELECT x FROM t WHERE 1 = 1

true（） 和 false（） 常量在 and_（） 或 or_（） 中还具有 “短路”作连接：

>>> print(select(t.c.x).where(or_(t.c.x>5,true())))SELECT x FROM t WHERE true
>>> print(select(t.c.x).where(and_(t.c.x>5,false())))SELECT x FROM t WHERE false

另请参阅

假（）

函数 sqlalchemy.sql.expression 中。try_cast（表达式：_ColumnExpressionOrLiteralArgument[Any]，type_：_TypeEngineArgument[_T]）→ TryCast[_T]¶

为支持它的后端生成一个 TRY_CAST 表达式;这是一个 CAST，对于不可强制转换的转换返回 NULL。

在 SQLAlchemy 中，此构造仅受 SQL Server 方言支持，如果在其他包含的后端上使用，将引发 CompileError。但是，第三方后端也可能支持此结构。

提示

由于 try_cast（） 源自 SQL Server 方言，因此它既可以从 sqlalchemy 导入。也可以从 sqlalchemy.dialects.mssql 的

try_cast（） 返回 TryCast 的实例，其行为通常类似于 Cast 构造;在 SQL 级别，CAST 和 TRY_CAST 之间的区别是 TRY_CAST 为不可强制转换的表达式返回 NULL，例如尝试将字符串 “hi” 强制转换为整数值。

例如：

from sqlalchemy import select, try_cast, Numeric

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

上述内容将在 Microsoft SQL Server 上呈现为：

SELECT TRY_CAST (product_table.unit_price AS NUMERIC(10, 4))
FROM product_table

2.0.14 版中的新功能： try_cast（） 已从 SQL Server 方言推广为其他方言可能支持的通用结构。

函数 sqlalchemy.sql.expression 中。tuple_（*clauses： _ColumnExpressionArgument[Any]， types：Sequence[_TypeEngineArgument[Any]]None=None）→ 元组¶

返回一个 Tuple。

主要用途是使用 ColumnOperators.in_（）

from sqlalchemy import tuple_

tuple_(table.c.col1, table.c.col2).in_([(1, 2), (5, 12), (10, 19)])

在 1.3.6 版本发生变更：添加了对 SQLite IN 元组的支持。

警告

并非所有后端都支持复合 IN 结构，并且目前已知可在 PostgreSQL、MySQL 和 SQLite 上运行。不支持的后端将引发 DBAPIErr或调用此类表达式时。

函数 sqlalchemy.sql.expression 中。type_coerce（表达式：_ColumnExpressionOrLiteralArgument[Any]，type_：_TypeEngineArgument[_T]）→ TypeCoerce[_T]¶

将 SQL 表达式与特定类型关联，而不进行渲染 CAST 的。

例如：

from sqlalchemy import type_coerce

stmt = select(type_coerce(log_table.date_string, StringDateTime()))

上述构造将生成一个 TypeCoerce 对象，该对象不会在 SQL 端以任何方式修改渲染，但如果在 columns 子句上下文中使用，则生成的标签可能例外：

SELECT date_string AS date_string FROM log

当提取结果行时，StringDateTime 类型处理器将代表 date_string 列应用于结果行。

注意

type_coerce（） 结构不会呈现自己的任何 SQL 语法，包括它不意味着括号。请使用 TypeCoerce.self_group（） 如果需要显式括号。

为了为表达式提供命名标签，请使用 ColumnElement.label（） 中：

stmt = select(
    type_coerce(log_table.date_string, StringDateTime()).label("date")
)

当文本值或 bindparam（） 构造作为目标传递给 type_coerce（） 时，具有 bound-value 处理功能的类型也将使该行为生效。例如，如果类型实现 TypeEngine.bind_expression（） method 或 TypeEngine.bind_processor（） 方法或等效方法，则当传递文本值时，这些函数将在语句编译/执行时生效，如下所示：

# bound-value handling of MyStringType will be applied to the
# literal value "some string"
stmt = select(type_coerce("some string", MyStringType))

将 type_coerce（） 与组合表达式一起使用时，请注意 括号不适用。如果 type_coerce（） 在运算符上下文中使用，其中通常需要 CAST 中的括号，请使用 TypeCoerce.self_group（） 方法：

>>> some_integer=column("someint",Integer)>>> some_string=column("somestr",String)>>> expr=type_coerce(some_integer+5,String)+some_string>>> print(expr)someint + :someint_1 || somestr
>>> expr=type_coerce(some_integer+5,String).self_group()+some_string>>> print(expr)(someint + :someint_1) || somestr

参数

expression¶– SQL 表达式，例如 ColumnElement （列元素） expression 或一个 Python 字符串，该字符串将被强制转换为一个 bound literal 值。
type_¶– 一个 TypeEngine 类或实例，指示表达式被强制转换为的类型。

另请参阅

ColumnElement.between（）

类 sqlalchemy.sql.expression 中。quoted_name¶

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

quoted_name 是一个 Python unicode/str 子类，它表示特定的标识符名称以及 quote 标志。此引号标志设置为 True 或 False 将覆盖此标识符的自动引用行为，以便无条件引用或不引用名称。如果保留为默认值 None，则根据对令牌本身的检查，将基于每个后端的引用行为应用于标识符。

在所谓的 “name normalize” 选项的情况下，也会阻止修改 quote=True 的 quoted_name 对象。某些数据库后端（如 Oracle Database、Firebird 和 DB2）将不区分大小写的名称“规范化”为大写。这些后端的 SQLAlchemy 方言从 SQLAlchemy 的小写表示不敏感约定转换为这些后端的大写表示不敏感约定。此处的 quote=True 标志将阻止此转换的发生，以支持在此类后端中以全小写形式引用的标识符。

quoted_name 对象通常是自动创建的为键 Schema 结构指定名称时，例如 Table、Column 等。该类也可以作为 name 显式传递给任何接收可引用名称的函数。例如使用 Engine.has_table（） method 替换为无条件引用的名称：

from sqlalchemy import create_engine
from sqlalchemy import inspect
from sqlalchemy.sql import quoted_name

engine = create_engine("oracle+oracledb://some_dsn")
print(inspect(engine).has_table(quoted_name("some_table", True)))

上述逻辑将针对 Oracle 数据库后端运行“has table”逻辑，将名称完全作为“some_table”传递，而不转换为大写。

在 1.2 版本发生变更： 除了 sqlalchemy.sql.elements 的先前位置外，quoted_name 构造现在还可以从 sqlalchemy.sql 导入。

成员

报价

类签名

类 sqlalchemy.sql.expression.quoted_name （ sqlalchemy.util.langhelpers.MemoizedSlots ， builtins.str）

属性 sqlalchemy.sql.expression.quoted_name. 引用¶: 是否应无条件引用字符串

Column Element 修饰符构造函数¶

此处列出的函数更常作为任何 ColumnElement 结构，例如 label（） 函数通常通过 ColumnElement.label（） 方法。

对象名称	描述
all_（expr）	生成 ALL 表达式。
any_（expr）	生成 ANY 表达式。
ASC（列）	生成一个升序的 `ORDER BY` 子句元素。
between（expr， lower_bound， upper_bound[，对称]）	生成 `BETWEEN` 谓词子句。
collate（表达式，排序规则）	返回子句`表达式 COLLATE collation`。
desc（列）	生成降序 `ORDER BY` 子句元素。
funcfilter（func， *criterion）	针对函数生成 `FunctionFilter` 对象。
label（名称，元素[， type_]）	返回给定 `ColumnElement` 的 `Label` 对象。
nulls_first（列）	为 `ORDER BY` 表达式生成 `NULLS FIRST` 修饰符。
nulls_last（列）	为 `ORDER BY` 表达式生成 `NULLS LAST` 修饰符。
nullsfirst	`nulls_first（）` 函数的同义词。
nullslast	`nulls_last（）` 函数的旧同义词。
over（元素[， partition_by， order_by， range_， ...]）	针对函数生成 `Over` 对象。
within_group（元素， *order_by）	针对函数生成 `WithinGroup` 对象。

函数 sqlalchemy.sql.expression 中。all_（expr： _ColumnExpressionArgument[_T]）→ CollectionAggregate[bool]¶

生成 ALL 表达式。

对于 PostgreSQL 等方言，此运算符适用于 ARRAY 数据类型的使用，对于 MySQL 的方言，它可能适用于子查询。例如：

# renders on PostgreSQL:
# '5 = ALL (somearray)'
expr = 5 == all_(mytable.c.somearray)

# renders on MySQL:
# '5 = ALL (SELECT value FROM table)'
expr = 5 == all_(select(table.c.value))

与 NULL 的比较可以使用 None ：

None == all_(mytable.c.somearray)

any_（） / all_（）运算符还具有特殊的 “作数翻转” 行为，因此，如果在比较的左侧使用 any_（） / all_（），则使用独立的运算符，例如 ==、！= 等。（不包括运算符方法，例如 ColumnOperators.is_（））渲染的表达式被翻转：

# would render '5 = ALL (column)`
all_(mytable.c.column) == 5

或者使用 None，该注释不会像 NULL 那样执行呈现 “IS” 的通常步骤：

# would render 'NULL = ALL(somearray)'
all_(mytable.c.somearray) == None

在 1.4.26 版本发生变更：修复了 any_（） / all_（）的使用，与右侧的 NULL 相比，它被向左翻转。

列级 ColumnElement.all_（） 方法（不要与 ARRAY 级别混淆 Comparator.all（））是 all_（col））：

5 == mytable.c.somearray.all_()

另请参阅

ColumnOperators.all_（）

any_（）

函数 sqlalchemy.sql.expression 中。any_（expr： _ColumnExpressionArgument[_T]）→ CollectionAggregate[bool]¶

生成 ANY 表达式。

对于 PostgreSQL 等方言，此运算符适用于 ARRAY 数据类型的使用，对于 MySQL 的方言，它可能适用于子查询。例如：

# renders on PostgreSQL:
# '5 = ANY (somearray)'
expr = 5 == any_(mytable.c.somearray)

# renders on MySQL:
# '5 = ANY (SELECT value FROM table)'
expr = 5 == any_(select(table.c.value))

与 NULL 的比较可以使用 None 或 null（） ：

None == any_(mytable.c.somearray)

any_（） / all_（）运算符还具有特殊的 “作数翻转” 行为，因此，如果在比较的左侧使用 any_（） / all_（），则使用独立的运算符，例如 ==、！= 等。（不包括运算符方法，例如 ColumnOperators.is_（））渲染的表达式被翻转：

# would render '5 = ANY (column)`
any_(mytable.c.column) == 5

或者使用 None，该注释不会像 NULL 那样执行呈现 “IS” 的通常步骤：

# would render 'NULL = ANY(somearray)'
any_(mytable.c.somearray) == None

在 1.4.26 版本发生变更：修复了 any_（） / all_（）的使用，与右侧的 NULL 相比，它被向左翻转。

列级 ColumnElement.any_（） 方法（不要与 ARRAY 级别混淆 Comparator.any（））是 any_（col））：

5 = mytable.c.somearray.any_()

另请参阅

ColumnOperators.any_（）

all_（）

函数 sqlalchemy.sql.expression 中。asc（column： _ColumnExpressionOrStrLabelArgument[_T]）→ 一元表达式[_T]¶

生成一个升序的 ORDER BY 子句元素。

例如：

from sqlalchemy import asc

stmt = select(users_table).order_by(asc(users_table.c.name))

将生成 SQL 为：

SELECT id, name FROM user ORDER BY name ASC

asc（） 函数是 ColumnElement.asc（） method 在所有 SQL 表达式上可用，例如：

stmt = select(users_table).order_by(users_table.c.name.asc())

参数: column¶- 一个 ColumnElement（例如标量 SQL 表达式），用于应用 asc（）作。

另请参阅

函数 sqlalchemy.sql.expression 中。between（expr： _ColumnExpressionOrLiteralArgument[_T]， lower_bound：任意， upper_bound：任意， 对称： bool = False）→ BinaryExpression[bool]¶

生成 BETWEEN 谓词子句。

例如：

from sqlalchemy import between

stmt = select(users_table).where(between(users_table.c.id, 5, 7))

将生成类似于以下内容的 SQL：

SELECT id, name FROM user WHERE id BETWEEN :id_1 AND :id_2

between（） 函数是 ColumnElement.between（） 方法，如下所示：

stmt = select(users_table).where(users_table.c.id.between(5, 7))

如果值不是 ColumnElement 子类，则传递给 between（） 的所有参数（包括左侧列表达式）都会从 Python 标量值中强制执行。例如，可以比较三个固定值，如下所示：

print(between(5, 3, 7))

这将产生：

:param_1 BETWEEN :param_2 AND :param_3

参数

expr¶ – 列表达式，通常为 ColumnElement （列元素） 实例，或者是要强制的 Python 标量表达式转换为列表达式，作为 BETWEEN 表达。
lower_bound¶ – 用作 BETWEEN 表达式右侧的下限的列或 Python 标量表达式。
upper_bound¶ – 用作 BETWEEN 表达式右侧的上限的列或 Python 标量表达式。
symmetric¶ – 如果为 True，将呈现 “ BETWEEN SYMMETRIC ”。请注意，并非所有数据库都支持此语法。

另请参阅

函数 sqlalchemy.sql.expression 中。collate（表达式：_ColumnExpressionArgument[str]，排序规则：str）→ BinaryExpression[str]¶

返回子句表达式 COLLATE collation。

例如：

collate(mycolumn, "utf8_bin")

生产：

mycolumn COLLATE utf8_bin

如果排序规则表达式是区分大小写的标识符，例如包含大写字符，则也会引用该排序规则表达式。

在 1.2 版本发生变更：如果 COLLATE 表达式区分大小写，则引用会自动应用于 COLLATE 表达式。

函数 sqlalchemy.sql.expression 中。desc（column： _ColumnExpressionOrStrLabelArgument[_T]）→ 一元表达式[_T]¶

生成降序 ORDER BY 子句元素。

例如：

from sqlalchemy import desc

stmt = select(users_table).order_by(desc(users_table.c.name))

将生成 SQL 为：

SELECT id, name FROM user ORDER BY name DESC

desc（） 函数是 ColumnElement.desc（） method 在所有 SQL 表达式上可用，例如：

stmt = select(users_table).order_by(users_table.c.name.desc())

参数: column¶- 一个 ColumnElement （例如标量 SQL 表达式），用于应用 desc（）作。

另请参阅

函数 sqlalchemy.sql.expression 中。funcfilter（func： FunctionElement[_T]， *criterion： _ColumnExpressionArgument[bool]）→函数过滤器[_T]¶

针对函数生成 FunctionFilter 对象。

用于聚合和窗口函数，用于支持 “FILTER” 子句的数据库后端。

例如：

from sqlalchemy import funcfilter

funcfilter(func.count(1), MyClass.name == "some name")

将生成 “COUNT（1） FILTER （WHERE myclass.name = 'some name'）”。

此功能也可从 func 获得构造自身。

另请参阅

特殊修饰符 WITHIN GROUP， FILTER - 在 SQLAlchemy Unified 教程

FunctionElement.filter（）

函数 sqlalchemy.sql.expression 中。label（name： str， element： _ColumnExpressionArgument[_T]， type_：_TypeEngineArgument[_T]None=None）→ 标签[_T]¶

返回给定 ColumnElement 的 Label 对象。

标签更改 SELECT 语句，通常通过 AS SQL 关键字。

此功能可以通过 ColumnElement.label（） 方法 ColumnElement 的 ColumnElement 中。

参数

name¶ – 标签名称
obj¶ —— 一个 ColumnElement 。

函数 sqlalchemy.sql.expression 中。nulls_first（column： _ColumnExpressionArgument[_T]）→ 一元表达式[_T]¶

为 ORDER BY 表达式生成 NULLS FIRST 修饰符。

nulls_first（） 旨在修改 asc（） 或 desc（） 生成的表达式，并指示在排序过程中遇到 NULL 值时应如何处理它们：

from sqlalchemy import desc, nulls_first

stmt = select(users_table).order_by(nulls_first(desc(users_table.c.name)))

上述 SQL 表达式类似于：

SELECT id, name FROM user ORDER BY name DESC NULLS FIRST

与 asc（） 和 desc（） 一样，nulls_first（） 通常为使用 ColumnElement.nulls_first（） 的函数版本，而不是作为其独立函数版本，如下所示：

stmt = select(users_table).order_by(
    users_table.c.name.desc().nulls_first()
)

在 1.4 版本发生变更： nulls_first（） 已从 nullsfirst（）的 URL 示例。以前的名称仍然可用于向后兼容。

另请参阅

函数 sqlalchemy.sql.expression 中。nullsfirst（）¶: nulls_first（） 函数的同义词。

在 2.0.5 版本发生变更：恢复了缺失的旧符号 nullsfirst（）。

函数 sqlalchemy.sql.expression 中。nulls_last（列： _ColumnExpressionArgument[_T]）→ 一元表达式[_T]¶

为 ORDER BY 表达式生成 NULLS LAST 修饰符。

nulls_last（） 旨在修改 asc（） 或 desc（） 生成的表达式，并指示在排序过程中遇到 NULL 值时应如何处理它们：

from sqlalchemy import desc, nulls_last

stmt = select(users_table).order_by(nulls_last(desc(users_table.c.name)))

上述 SQL 表达式类似于：

SELECT id, name FROM user ORDER BY name DESC NULLS LAST

与 asc（） 和 desc（） 一样，nulls_last（） 通常为使用 ColumnElement.nulls_last（），而不是作为其独立函数版本，如下所示：

stmt = select(users_table).order_by(users_table.c.name.desc().nulls_last())

在 1.4 版本发生变更： nulls_last（） 从 nullslast（）的 URL 中。以前的名称仍然可用于向后兼容。

另请参阅

函数 sqlalchemy.sql.expression 中。nullslast（）¶: nulls_last（） 函数的旧同义词。

在 2.0.5 版本发生变更：恢复了缺失的遗留符号 nullslast（）。

函数 sqlalchemy.sql.expression 中。over（element： FunctionElement[_T]， partition_by：_ByArgumentNone=无， order_by：_ByArgumentNone=无， range_：typing_Tuple[intNone，intNone]None=无， rows：typing_Tuple[intNone，intNone]None=无）→ over[_T]¶

针对函数生成 Over 对象。

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

over（） 通常使用 FunctionElement.over（） 方法调用，例如：

func.row_number().over(order_by=mytable.c.some_column)

将产生：

ROW_NUMBER() OVER(ORDER BY some_column)

也可以使用 over.range_ 和 over.rows 参数。这些互斥参数都接受一个 2 元组，其中包含整数和 None 的组合：

func.row_number().over(order_by=my_table.c.some_column, range_=(None, 0))

以上将产生：

ROW_NUMBER() OVER(ORDER BY some_column
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)

值 None 表示“无界”，值 0 表示“当前行”，负/正整数表示“preceding”和“following”：

范围介于前面 5 个和后面 10 个之间：

func.row_number().over(order_by="x", range_=(-5, 10))

UNBOUNDED PRECEDING 行和 CURRENT 行之间的行：

func.row_number().over(order_by="x", rows=(None, 0))

范围介于 2 个 PRECEDING 和 UNBOUNDED FOLLOWING 之间：
```
func.row_number().over(order_by="x", range_=(-2, None))
```

范围介于 1 FOLLOWING 和 3 FOLLOWING 之间：

func.row_number().over(order_by="x", range_=(1, 3))

参数

element¶—— 一个 FunctionElement、WithinGroup 或其他兼容的结构。
partition_by¶ – 一个列元素或字符串，或一个列表，将用作 OVER 结构的 PARTITION BY 子句。
order_by¶ – 将用作 OVER 结构的 ORDER BY 子句的列元素或字符串，或类似的列表。
range_¶ – 窗口的可选 range 子句。这是一个元组值，可以包含整数值或 None，并将呈现 RANGE BETWEEN PRECEDING / FOLLOWING 子句。
rows¶ – 窗口的可选 rows 子句。这是一个元组值，可以包含整数值或 None，并将呈现 ROWS BETWEEN PRECEDING / FOLLOWING 子句。

此功能也可从 func 获得通过 FunctionElement.over（） 方法构造自身。

另请参阅

使用窗口函数 - 在 SQLAlchemy Unified 教程中

函数

within_group（）

函数 sqlalchemy.sql.expression 中。within_group（element： FunctionElement[_T]， *order_by： _ColumnExpressionArgument[Any]）→内部组[_T]¶

针对函数生成 WithinGroup 对象。

用于所谓的“有序集聚合”和“假设集聚合”函数，包括 percentile_cont、 等级、dense_rank等

within_group（） 通常使用该方法 FunctionElement.within_group() 调用，例如：

from sqlalchemy import within_group

stmt = select(
    department.c.id,
    func.percentile_cont(0.5).within_group(department.c.salary.desc()),
)

上述语句将生成类似于 SELECT department.id, percentile_cont(0.5) WITHIN GROUP (ORDER BY department.salary DESC) .

参数

element¶—— 一个 FunctionElement 结构，通常由 func 生成。
*order_by¶– 将用作 WITHIN GROUP 结构的 ORDER BY 子句的一个或多个列元素。

另请参阅

特殊修饰符 WITHIN GROUP， FILTER - 在 SQLAlchemy Unified 教程

函数

over（）

Column Element 类文档¶

此处的类是使用 Column Element 基础构造函数和 Column 元素修饰符构造函数。

对象名称	描述
二进制表达式	表示 `LEFT <operator> RIGHT 的`表达式。
BindParameter （绑定参数）	表示 “bound expression”。
箱	表示 `CASE` 表达式。
投	表示 `CAST` 表达式。
子句列表	描述由运算符分隔的子句列表。
ColumnClause	表示来自任何文本字符串的列表达式。
ColumnCollection 系列	`ColumnElement` 实例的集合，通常用于 `FromClause` 对象。
ColumnElement （列元素）	表示适合在语句的 “columns” 子句、WHERE 子句等中使用的面向列的 SQL 表达式。
ColumnExpressionArgument	通用的 “column expression” 参数。
列运算符	定义的布尔值、比较运算符和其他运算符 `ColumnElement` 表达式。
提取	表示 SQL EXTRACT 子句 `extract（field FROM expr）。`
假_	在 SQL 语句中表示 `false` 关键字或等效关键字。
FunctionFilter 函数	表示函数 FILTER 子句。
标签	表示列标签（AS）。
零	在 SQL 语句中表示 NULL 关键字。
运营商	比较基数和逻辑运算符。
多	表示 OVER 子句。
SQLColumn表达式	一种类型，可用于指示任何 SQL 列元素或对象，以代替一个元素或对象。
TextClause 的	表示文本 SQL 文本片段。
真_	在 SQL 语句中表示 `true` 关键字或等效关键字。
TryCast （试用）	表示 TRY_CAST 表达式。
元	表示 SQL 元组。
类型强制	表示 Python 端类型强制包装器。
UnaryExpression （一元表达式）	定义 'unary' 表达式。
内部组	表示 WITHIN GROUP （ORDER BY）子句。
WrapsColumnExpression	定义 `ColumnElement` 的 Mixin 作为带有特殊已具有 name 的表达式的标签行为。

类 sqlalchemy.sql.expression 中。二进制表达式¶

表示 LEFT <operator> RIGHT 的表达式。

每当在 Python 二进制表达式中使用两个列表达式时，都会自动生成 BinaryExpression：

>>> fromsqlalchemy.sqlimportcolumn>>> column("a")+column("b")<sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>>>> print(column("a")+column("b"))a + b

类签名

类 sqlalchemy.sql.expression.BinaryExpression （ sqlalchemy.sql.expression.OperatorExpression ）

类 sqlalchemy.sql.expression 中。BindParameter（绑定参数）¶

表示 “bound expression”。

BindParameter 使用 bindParam（） 函数，如下所示：

from sqlalchemy import bindparam

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

有关如何使用 BindParameter 的详细讨论，请参阅 bindparam（）。

另请参阅

bindparam（）

成员

effective_value、inherit_cache、render_literal_execute（）

类签名

类 sqlalchemy.sql.expression.BindParameter （ sqlalchemy.sql.roles.InElementRole ， sqlalchemy.sql.expression.KeyedColumnElement ）

属性 sqlalchemy.sql.expression.BindParameter. effective_value¶

返回此绑定参数的值，同时考虑是否设置了可调用参数。

将评估可调用值，如果存在，则返回 else value。

属性 sqlalchemy.sql.expression.BindParameter. inherit_cache：boolNone = True¶

指示此 HasCacheKey 实例是否应使用其直接超类使用的缓存键生成方案。

该属性默认为 None，这表示构造尚未考虑是否适合参与缓存;这在功能上等效于将值设置为 False，但还会发出警告。

如果与对象对应的 SQL 不基于此类的本地属性而不是其超类而更改，则可以在特定类上将此标志设置为 True。

另请参阅

启用对自定义构造的缓存支持 - 设置 HasCacheKey.inherit_cache 第三方或用户定义的 SQL 构造的属性。

方法 sqlalchemy.sql.expression.BindParameter. render_literal_execute（）→ BindParameter[_T]¶

生成此绑定参数的副本，该副本将启用 BindParameter.literal_execute 标志。

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

在 1.4.5 版本加入.

另请参阅

第三方方言的缓存

类 sqlalchemy.sql.expression 中。案例¶

表示 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（）。

另请参阅

案例（）

类签名

类 sqlalchemy.sql.expression.Case （ sqlalchemy.sql.expression.ColumnElement ）

类 sqlalchemy.sql.expression 中。转换¶

表示 CAST 表达式。

Cast 是使用 cast（） 工厂函数生成的，如下所示：

from sqlalchemy import cast, Numeric

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

有关 Cast 用法的详细信息，请参见 cast（）。

另请参阅

try_cast（）

type_coerce（） - CAST 的替代方案，仅在 Python 端强制类型，这通常足以生成正确的 SQL 和数据强制。

类签名

类 sqlalchemy.sql.expression.Cast （ sqlalchemy.sql.expression.WrapsColumnExpression ）

类 sqlalchemy.sql.expression 中。子句列表¶

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

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

成员

类签名

类 sqlalchemy.sql.expression.ClauseList （ sqlalchemy.sql.roles.InElementRole ， sqlalchemy.sql.roles.OrderByRole ， sqlalchemy.sql.roles.ColumnsClauseRole ， sqlalchemy.sql.roles.DMLColumnRole sqlalchemy.sql.expression.DQLDMLClauseElement ，）

方法 sqlalchemy.sql.expression.ClauseList. self_group（against：OperatorTypeNone=None）→SelfGrouping[Any]¶

将 'grouping' 应用于此 ClauseElement。

此方法被 subclasses 覆盖以返回 “grouping” 结构，即括号。特别是，当它被 “binary” 表达式用于在放入更大的表达式时提供围绕自身的分组，以及 select（） 构造 select（） 的（请注意，子查询通常应使用 Select.alias（） 方法创建，因为许多平台需要命名嵌套的 SELECT 语句）。

由于表达式是组合在一起的，因此 self_group（） 是自动的 - 最终用户代码永远不需要直接使用此方法。请注意，SQLAlchemy 的子句构造考虑了运算符优先级 - 因此可能不需要括号，例如，在像 x OR （y AND z） 这样的表达式中 - AND 优先于 OR。

的 base self_group（） 方法 子句元素 只返回 self。

类 sqlalchemy.sql.expression 中。ColumnClause 的

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

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 对象。当列 class 具有所有与 ColumnClause 相同的功能，即 ColumnClause 类在行为要求的情况下单独可用仅限于简单的 SQL 表达式生成。对象没有与 Schema-level metadata 或 execution-time 的关联行为，所以从这个意义上说，它是 Column 的“轻量级”版本。

有关 ColumnClause 用法的完整详细信息，请参阅 column（）的

另请参阅

列（）

列

成员

get_children（）

类签名

类 sqlalchemy.sql.expression.ColumnClause （ sqlalchemy.sql.roles.DDLReferredColumnRole ， sqlalchemy.sql.roles.LabeledColumnExprRole ， sqlalchemy.sql.roles.StrAsPlainColumnRole ， sqlalchemy.sql.expression.Immutable sqlalchemy.sql.expression.NamedColumn ，）

方法 sqlalchemy.sql.expression.ColumnClause. get_children（*， column_tables=False， **kw）¶

返回紧接的子 HasTraverseInternals 元素中。

这用于访问遍历。

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

类 sqlalchemy.sql.expression 中。ColumnCollection¶

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

ColumnCollection 对象通常作为 Table 对象上的 Table.c 或 Table.columns 集合提供，在访问表和列。

ColumnCollection 具有类似 mapping 和 sequence 的行为。ColumnCollection 通常存储 Column 对象，然后可以通过映射样式访问和属性访问样式来访问这些对象。

要使用普通属性样式访问来访问 Column 对象，请像指定任何其他对象属性一样指定名称，例如下面访问名为 employee_name 的列：

>>> employee_table.c.employee_name

要访问名称中包含特殊字符或空格的列，索引样式的访问，如下所示，它说明了名为访问 Employee 的付款：

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

由于 ColumnCollection 对象提供了一个 Python 字典 interface，常见的字典方法名称，如 ColumnCollection.keys（）、ColumnCollection.values（） 和 ColumnCollection.items（） 可用，这意味着在这些名称下键控的数据库列也需要使用索引访问：

>>> employee_table.c["values"]

存在 Column 的名称通常是 Column.key 参数的名称。在某些上下文中，例如使用通过 Select.set_label_style（） 方法设置的标签样式的 Select 对象，特定键的列可能改为表示在特定标签名称下，例如 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 类，以便在需要重复数据删除以及其他替换/删除作的情况下保持以前的行为。

成员

add（）， as_readonly（）， clear（）， compare（）， contains_column（）， corresponding_column（）， get（）， items（）， keys（）， update（）， values（）

类签名

类 sqlalchemy.sql.expression.ColumnCollection （键入。通用）

method sqlalchemy.sql.expression.ColumnCollection. add（column： ColumnElement[Any]， key：_COLKEYNone=None）→ None¶: 向此 ColumnCollection 添加一列。

注意

面向用户的代码通常不使用此方法，因为 ColumnCollection 通常是现有对象（如 Table）的一部分。要添加 列添加到现有 Table object，请使用 Table.append_column（） 方法。

方法 sqlalchemy.sql.expression.ColumnCollection. as_readonly（）→ ReadOnlyColumnCollection[_COLKEY， _COL_co]¶: 返回 this 的 “只读” 形式 ColumnCollection 的 ColumnCollection 中。

方法 sqlalchemy.sql.expression.ColumnCollection. clear（）→ NoReturn¶: 未为 ColumnCollection 的 ColumnCollection 中。

方法 sqlalchemy.sql.expression.ColumnCollection. compare（other： ColumnCollection[Any， Any]）→ bool¶: 根据键的名称将此 ColumnCollection 与另一个 ColumnCollection 进行比较

方法 sqlalchemy.sql.expression.ColumnCollection. contains_column（col： ColumnElement[Any]）→ bool¶: 检查此集合中是否存在列对象

方法 sqlalchemy.sql.expression.ColumnCollection. corresponding_column（column： _COL， require_embedded： bool = False）→_COL_COL_coNone¶

给定一个 ColumnElement，返回导出的 ColumnElement 对象 ColumnCollection 系列对应于该原始 ColumnElement 通过公共 ancestor 列。

参数

column¶—— 目标 ColumnElement 进行匹配。
require_embedded¶ —— 如果给定的 ColumnElement ColumnElement （列元素） 实际上存在于子元素中的这个 Selectable。通常，如果该列仅与此 Selectable 的导出列之一共享一个共同的祖先，则该列将匹配。

另请参阅

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

在 1.4 版本发生变更： corresponding_column 已移动到 ColumnCollection 本身。

方法 sqlalchemy.sql.expression.ColumnCollection. get（key： str， default：_COLNone=None）→_COL_COL_coNone¶: 获取 ColumnClause 或 Column 对象基于来自 this 的字符串键名称 ColumnCollection 的 ColumnCollection 中。

方法 sqlalchemy.sql.expression.ColumnCollection. items（）→ List[元组[_COLKEY， _COL_co]]¶: 返回 this 中所有列的（key， column）元组序列集合，每个集合由一个字符串、键名称和一个 ColumnClause 或 Column 对象。

方法 sqlalchemy.sql.expression.ColumnCollection. keys（）→ List[_COLKEY]¶: 返回此集合中所有列的字符串键名称序列。

method sqlalchemy.sql.expression.ColumnCollection. update（iter_： Any）→ NoReturn¶: 字典 update（）未实现 ColumnCollection 的 ColumnCollection 中。

method sqlalchemy.sql.expression.ColumnCollection. values（）→ List[_COL_co]¶: 返回 ColumnClause 或 此集合中所有列的 Column 对象。

类 sqlalchemy.sql.expression 中。ColumnElement（列元素）¶

表示适合在语句的 “columns” 子句、WHERE 子句等中使用的面向列的 SQL 表达式。

虽然最熟悉的 ColumnElement 类型是 Column 对象 ColumnElement 作为基础对于 SQL 表达式中可能存在的任何单位，包括表达式本身、SQL 函数、绑定参数、文本表达式、关键字（如 NULL 等）。 ColumnElement （列元素） 是所有此类元素的最终基类。

各种各样的 SQLAlchemy Core 函数在 SQL 表达式中工作级别，并且旨在接受 ColumnElement 设置为参数。这些函数通常会记录它们接受 “SQL expression” 作为参数。这在 SQLAlchemy 中意味着什么通常是指已经采用 ColumnElement 对象，或者一个可以强制转换为一个值的值。大多数（但不是全部）SQLAlchemy 核心函数遵循的 SQL 表达式强制规则如下：

文本 Python 值（例如字符串、整数或浮点值、布尔值、日期时间、Decimal 对象或几乎任何其他 Python 对象）将被强制转换为“文本绑定值”。这通常意味着将生成一个 bindparam（），其中包含嵌入到结构中的给定值;生成的 BindParameter 对象是 ColumnElement 的 ColumnElement 中。 Python 值最终将被发送作为 execute（） 或 executemany（） 方法，在 SQLAlchemy 之后特定于类型的转换器（例如，由任何关联的 TypeEngine 对象）应用于该值。

任何特殊的对象值，通常是 ORM 级别的构造，具有名为 __clause_element__（）的访问器。当一个未知类型的对象被传递给一个函数时，Core 表达式系统会查找此方法，该函数希望将参数强制转换为 ColumnElement，有时是 SelectBase 表达式。它在 ORM 中用于将特定于 ORM 的对象（如映射类和映射属性）转换为 Core 表达式对象。

Python None 值通常解释为 NULL，在 SQLAlchemy Core 中生成 null（） 的实例。

ColumnElement 提供了生成新 ColumnElement （列元素） 对象。这意味着 Python 运算符如 ==、！= 和 < 被重载以模拟 SQL作，并允许进一步实例化 ColumnElement 实例它们由其他更基本的 ColumnElement （列元素） 对象。例如，可以使用加法运算符 + 将两个 ColumnClause 对象添加在一起，以生成 BinaryExpression。ColumnClause 和 BinaryExpression 都是 ColumnElement 的子类：

>>> fromsqlalchemy.sqlimportcolumn>>> column("a")+column("b")<sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>>>> print(column("a")+column("b"))a + b

另请参阅

列

列（）

成员

__eq__（）， __le__（）， __lt__（）， __ne__（）， all_（）， allows_lambda， anon_key_label， anon_label， any_（）， asc（）， base_columns， between（）， bitwise_and（）， bitwise_lshift（）， bitwise_not（）， bitwise_or（）， bitwise_rshift（）， bitwise_xor（）， bool_op（）， cast（）， collate（），比较器， compare（）， compile（）， concat（）， contains（）， desc（），描述， distinct（）， endswith（）， entity_namespace，表达式， foreign_keys， get_children（）， icontains（）， iendswith （）， ilike（）， in_（）， inherit_cache， is_（）， is_clause_element，is_distinct_from（）， is_dml， is_not（）， is_not_distinct_from（）， is_selectable， isnot（）， isnot_distinct_from（）， istartswith（），键，标签（）， like（）， match（）， negation_clause， not_ilike（）， not_in（）， not_like（）， notilike（）， notin_（）， notlike（）， nulls_first（）， nulls_last（）， nullsfirst（）， nullslast（），作（）、作（）、参数（）、primary_key、proxy_set、regexp_match（）、regexp_replace（）、reverse_operate（）、self_group（）、shares_lineage（）、startswith（）stringify_dialect、supports_execution、timetuple、type、unique_params（） uses_inspection

类签名

类 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.SQLColumnExpression sqlalchemy.sql.expression.DQLDMLClauseElement ）

方法 sqlalchemy.sql.expression.ColumnElement. __eq__（other： Any）→ ColumnOperators¶

继承自 sqlalchemy.sql.expression.ColumnOperators.__eq__ ColumnOperators 的方法

实现 == 运算符。

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

方法 sqlalchemy.sql.expression.ColumnElement. __le__（other： Any）→ ColumnOperators¶

继承自 sqlalchemy.sql.expression.ColumnOperators.__le__ ColumnOperators 的方法

实现 <= 运算符。

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

方法 sqlalchemy.sql.expression.ColumnElement. __lt__（other： Any）→ ColumnOperators¶

继承自 sqlalchemy.sql.expression.ColumnOperators.__lt__ ColumnOperators 的方法

实现 < 运算符。

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

方法 sqlalchemy.sql.expression.ColumnElement. __ne__（other： Any）→ ColumnOperators¶

继承自 sqlalchemy.sql.expression.ColumnOperators.__ne__ ColumnOperators 的方法

实现 ！= 运算符。

在列上下文中，生成子句 a ！= b。如果目标是 None，则生成 IS NOT NULL。

方法 sqlalchemy.sql.expression.ColumnElement. all_（）→ ColumnOperators¶

继承自ColumnOperators 的 ColumnOperators.all_（） 方法

针对父对象生成 all_（） 子句。

有关示例，请参阅 all_（） 的文档。

注意

一定不要混淆较新的 ColumnOperators.all_（） 方法替换为旧版版本，则 Comparator.all（） 方法，它使用不同的调用样式。

属性 sqlalchemy.sql.expression.ColumnElement. allows_lambda = True¶

属性 sqlalchemy.sql.expression.ColumnElement. anon_key_label¶: 1.4 版后已移除： ColumnElement.anon_key_label 属性现在是 private，而 public 访问器已弃用。

属性 sqlalchemy.sql.expression.ColumnElement. anon_label¶: 1.4 版后已移除： ColumnElement.anon_label 属性现在是 private，而 public 访问器已弃用。

方法 sqlalchemy.sql.expression.ColumnElement. any_（）→ ColumnOperators¶

继承自ColumnOperators 的 ColumnOperators.any_（） 方法

针对父对象生成 any_（） 子句。

有关示例，请参阅 any_（） 的文档。

注意

一定不要混淆较新的 ColumnOperators.any_（） 方法替换为旧版版本，则 Comparator.any（） 方法，它使用不同的调用样式。

方法 sqlalchemy.sql.expression.ColumnElement. asc（）→ ColumnOperators¶: 继承自ColumnOperators 的 ColumnOperators.asc（） 方法

针对父对象生成 asc（） 子句。

属性 sqlalchemy.sql.expression.ColumnElement. base_columns¶

method sqlalchemy.sql.expression.ColumnElement. between（cleft：任意， cright：任意， 对称： bool = False）→ ColumnOperators¶: 继承自 ColumnOperators 的 ColumnOperators.between（）方法

在给定下限和上限范围的情况下，针对父对象生成一个 between（） 子句。

方法 sqlalchemy.sql.expression.ColumnElement. bitwise_and（other： Any）→ ColumnOperators¶: 继承自ColumnOperators 的 ColumnOperators.bitwise_and（） 方法

产生一个按位的 AND 运算，通常通过 & 算子。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnElement. bitwise_lshift（other： Any）→ ColumnOperators¶: 继承自 ColumnOperators.bitwise_lshift() ColumnOperators 的方法

产生按位 LSHIFT 运算，通常通过 << 算子。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnElement. bitwise_not（）→ ColumnOperators¶: 继承自ColumnOperators 的 ColumnOperators.bitwise_not（） 方法

产生一个按位的 NOT 运算，通常通过 ~ 算子。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnElement. bitwise_or（other： Any）→ ColumnOperators¶: 继承自ColumnOperators 的 ColumnOperators.bitwise_or（） 方法

生成按位 OR 运算，通常通过 | 算子。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnElement. bitwise_rshift（other： Any）→ ColumnOperators¶: 继承自 ColumnOperators.bitwise_rshift() ColumnOperators 的方法

生成按位 RSHIFT 运算，通常通过 >> 算子。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnElement. bitwise_xor（other： Any）→ ColumnOperators¶: 继承自ColumnOperators 的 ColumnOperators.bitwise_xor（） 方法

生成按位 XOR 运算，通常通过 ^ 运算符，或者 # 表示 PostgreSQL。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnElement. bool_op（opstring： str， precedence： int = 0， python_impl：Callable[[...]，Any]None=None）→ Callable[[any]，运算符]¶

继承自Operators 的 Operators.bool_op（） 方法

返回自定义布尔运算符。

此方法是调用 Operators.op（） 并将 Operators.op.is_comparison flag 替换为 True。使用 Operators.bool_op（） 的主要优势是，当使用列构造时，返回的 expression 将用于 PEP 484 目的。

另请参阅

方法 sqlalchemy.sql.expression.ColumnElement. cast（type_： _TypeEngineArgument[_OPT]）→ cast[_OPT]¶

生成类型转换，即 CAST（<expression> AS <type>）。

这是 cast（） 函数的快捷方式。

另请参阅

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

type_coerce（）

方法 sqlalchemy.sql.expression.ColumnElement. collate（collation： str）→ ColumnOperators¶: 继承自ColumnOperators 的 ColumnOperators.collate（）方法

给定排序规则字符串，针对父对象生成 collate（） 子句。

另请参阅

collate（）

属性 sqlalchemy.sql.expression.ColumnElement. 比较器¶

method sqlalchemy.sql.expression.ColumnElement. compare（other： ClauseElement， **kw： Any）→ bool¶

继承自ClauseElement 的 ClauseElement.compare（） 方法

将此 ClauseElement 与给定的 ClauseElement 进行比较。

子类应覆盖默认行为，即直接的恒等比较。

**kw 是子类 compare（） 方法使用的参数，可用于修改比较条件（参见 ColumnElement）。

method sqlalchemy.sql.expression.ColumnElement. compile（bind：_HasDialectNone=None， dialect：DialectNone=None， **kw： Any）→ 已编译¶

继承自CompilerElement 的 CompilerElement.compile（） 方法

编译此 SQL 表达式。

返回值是一个 Compiled 对象。对返回值调用 str（） 或 unicode（） 将产生一个 string 表示形式。这 Compiled 对象还可以使用 params 访问器返回绑定参数名称和值的字典。

参数

bind¶– 一个 Connection 或 Engine，可以提供 Dialect 以生成 Compiled 对象。如果 bind 和 dialect 参数都省略了，而是使用默认的 SQL 编译器。
column_keys¶ – 用于 INSERT 和 UPDATE 语句，编译语句的 VALUES 子句中应存在的列名列表。如果为 None，则呈现目标表对象中的所有列。
dialect¶- 一个可以生成 Compiled 对象的 Dialect 实例。此参数优先于 bind 参数。
compile_kwargs¶ –

附加参数的可选字典，将在所有 “visit” 方法中传递给编译器。例如，这允许将任何自定义标志传递给自定义编译构造。它还用于传递 literal_binds 标志的情况：
```
from sqlalchemy.sql import table, column, select

t = table("t", column("x"))

s = select(t).where(t.c.x == 5)

print(s.compile(compile_kwargs={"literal_binds": True}))
```

另请参阅

method sqlalchemy.sql.expression.ColumnElement. concat（other： Any）→ ColumnOperators¶

继承自 ColumnOperators 的 ColumnOperators.concat（） 方法

实现 'concat' 运算符。

在列上下文中，生成子句 a || b，或在 MySQL 上使用 concat（） 运算符。

method sqlalchemy.sql.expression.ColumnElement. contains（other： Any， **kw： Any）→ ColumnOperators¶

继承自 ColumnOperators 的 ColumnOperators.contains（）方法

实现 'contains' 运算符。

生成一个 LIKE 表达式，该表达式针对字符串值中间的匹配项进行测试：

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

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.contains.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.contains.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.contains.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.contains("foo%bar", autoescape=True)
```
将渲染为：
```
somecolumn LIKE '%' || :param || '%' ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.contains("foo/%bar", escape="^")
```
将渲染为：
```
somecolumn LIKE '%' || :param || '%' ESCAPE '^'
```
该参数也可以与 ColumnOperators.contains.autoescape ：
```
somecolumn.contains("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

方法 sqlalchemy.sql.expression.ColumnElement. desc（）→ ColumnOperators¶: 继承自 ColumnOperators 的 ColumnOperators.desc（） 方法

针对父对象生成 desc（） 子句。

属性 sqlalchemy.sql.expression.ColumnElement. 说明¶: 继承自ClauseElement 的 ClauseElement.description属性

method sqlalchemy.sql.expression.ColumnElement. distinct（）→ 列运算符¶: 继承自ColumnOperators 的 ColumnOperators.distinct（）方法

针对父对象生成 distinct（） 子句。

method sqlalchemy.sql.expression.ColumnElement. endswith（other： Any， escape：strNone=None， autoescape： bool = False）→ 列运算符¶

继承自 ColumnOperators 的 ColumnOperators.endswith（）方法

实现 'endswith' 运算符。

生成一个 LIKE 表达式，该表达式针对字符串值末尾的匹配项进行测试：

column LIKE '%' || <other>

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.endswith.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.endswith.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.endswith.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.endswith("foo%bar", autoescape=True)
```
将渲染为：
```
somecolumn LIKE '%' || :param ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.endswith("foo/%bar", escape="^")
```
将渲染为：
```
somecolumn LIKE '%' || :param ESCAPE '^'
```
该参数也可以与 ColumnOperators.endswith.autoescape ：
```
somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

属性 sqlalchemy.sql.expression.ColumnElement. entity_namespace¶: 继承自 ClauseElement.entity_namespace ClauseElement 的属性

属性 sqlalchemy.sql.expression.ColumnElement. 表达式¶

返回列表达式。

部分检查界面;返回 self。

属性 sqlalchemy.sql.expression.ColumnElement. foreign_keys： AbstractSet[ForeignKey] = frozenset（{}）¶

方法 sqlalchemy.sql.expression.ColumnElement. get_children（*， omit_attrs： Tuple[str， ...] = （）， **kw： Any）→ Iterable[HasTraverseInternals]¶

继承自 HasTraverseInternals.get_children() HasTraverseInternals 的方法

返回紧接的子 HasTraverseInternals 元素中。

这用于访问遍历。

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

方法 sqlalchemy.sql.expression.ColumnElement. icontains（other： Any， **kw： Any）→ ColumnOperators¶

继承自ColumnOperators 的 ColumnOperators.icontains（） 方法

实现 icontains 运算符，例如 ColumnOperators.contains（） 的不区分大小写版本。

生成一个 LIKE 表达式，该表达式针对字符串值中间的不敏感匹配项进行测试：

lower(column) LIKE '%' || lower(<other>) || '%'

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.icontains.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.icontains.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.icontains.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.icontains("foo%bar", autoescape=True)
```
将渲染为：
```
lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.icontains("foo/%bar", escape="^")
```
将渲染为：
```
lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'
```
该参数也可以与 ColumnOperators.contains.autoescape ：
```
somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

method sqlalchemy.sql.expression.ColumnElement. iendswith（other： Any， escape：strNone=None， autoescape： bool = False）→ 列运算符¶

继承自 ColumnOperators 的 ColumnOperators.iendswith（）方法

实现 iendswith 运算符，例如 ColumnOperators.endswith（） 的不区分大小写版本。

生成一个 LIKE 表达式，该表达式针对字符串值末尾的不敏感匹配项进行测试：

lower(column) LIKE '%' || lower(<other>)

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.iendswith.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.iendswith.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.iendswith.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.iendswith("foo%bar", autoescape=True)
```
将渲染为：
```
lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.iendswith("foo/%bar", escape="^")
```
将渲染为：
```
lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'
```
该参数也可以与 ColumnOperators.iendswith.autoescape ：
```
somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

方法 sqlalchemy.sql.expression.ColumnElement. ilike（other： Any， escape：strNone=None）→ 列运算符¶

继承自ColumnOperators 的 ColumnOperators.ilike（） 方法

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

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

lower(a) LIKE lower(other)

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

a ILIKE other

例如：

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

参数

other¶ – 要比较的表达式
转义¶ –

可选的转义字符，将 ESCAPE 关键字，例如：
```
somecolumn.ilike("foo/%bar", escape="/")
```

另请参阅

ColumnOperators.is_not（）

方法 sqlalchemy.sql.expression.ColumnElement. in_（other： Any）→ ColumnOperators¶

继承自ColumnOperators 的 ColumnOperators.in_（） 方法

实现 in 运算符。

在列上下文中，生成子句列 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_([]))
```
在此调用形式中，表达式呈现 “empty set” 表达式。这些表达式是针对各个后端量身定制的，通常尝试获取空的 SELECT 语句作为子查询。例如在 SQLite 上，表达式为：
```
WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
在 1.4 版本发生变更：空的 IN 表达式现在在所有情况下都使用执行时生成的 SELECT 子查询。
如果绑定参数包含 bindparam.expanding 标志，则可以使用该参数，例如 bindparam（）：
```
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 版本加入：添加了 “expanding” 绑定参数

如果传递了空列表，则会呈现特定于正在使用的数据库的特殊“空列表”表达式。在 SQLite 上，这将是：
```
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
在 1.3 版本加入： “expanding” 绑定参数现在支持空列表

select（） 结构，通常是相关的标量 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¶ —— 一个字面值列表，一个 select（） 构造，或者包含 bindparam.expanding 标志设置为 True。

属性 sqlalchemy.sql.expression.ColumnElement. inherit_cache：boolNone = None¶

继承自HasCacheKey 的 HasCacheKey.inherit_cache属性

指示此 HasCacheKey 实例是否应使用其直接超类使用的缓存键生成方案。

该属性默认为 None，这表示构造尚未考虑是否适合参与缓存;这在功能上等效于将值设置为 False，但还会发出警告。

如果与对象对应的 SQL 不基于此类的本地属性而不是其超类而更改，则可以在特定类上将此标志设置为 True。

另请参阅

启用对自定义构造的缓存支持 - 设置 HasCacheKey.inherit_cache 第三方或用户定义的 SQL 构造的属性。

方法 sqlalchemy.sql.expression.ColumnElement. is_（other： Any）→ ColumnOperators¶

继承自ColumnOperators 的 ColumnOperators.is_（） 方法

实现 IS 运算符。

通常，在与值 None 进行比较时，会自动生成 IS，该值解析为 NULL。但是，如果与某些平台上的布尔值进行比较，则显式使用 IS 可能是可取的。

另请参阅

属性 sqlalchemy.sql.expression.ColumnElement. is_clause_element = True¶

方法 sqlalchemy.sql.expression.ColumnElement. is_distinct_from（other： Any）→ ColumnOperators¶

继承自 ColumnOperators.is_distinct_from() ColumnOperators 的方法

实现 IS DISTINCT FROM 运算符。

在大多数平台上呈现 “a IS DISTINCT FROM b”;在某些（例如 SQLite）上可能会呈现“a IS NOT b”。

属性 sqlalchemy.sql.expression.ColumnElement. is_dml = False¶

方法 sqlalchemy.sql.expression.ColumnElement. is_not（other： Any）→ ColumnOperators¶

继承自ColumnOperators 的 ColumnOperators.is_not（） 方法

实现 IS NOT 运算符。

通常，在与值 None 进行比较时，会自动生成 IS NOT，该值解析为 NULL。但是，如果与某些平台上的布尔值进行比较，则显式使用 IS NOT 可能是可取的。

在 1.4 版本发生变更： is_not（） 运算符已从 isnot（）的 API 中。以前的名称仍然可用于向后兼容。

另请参阅

方法 sqlalchemy.sql.expression.ColumnElement. is_not_distinct_from（other： Any）→ ColumnOperators¶

继承自 ColumnOperators.is_not_distinct_from() ColumnOperators 的方法

实现 IS NOT DISTINCT FROM 运算符。

在大多数平台上呈现 “a IS NOT DISTINCT WITH b”;在某些（例如 SQLite）上可能会呈现“a IS b”。

在 1.4 版本发生变更： is_not_distinct_from（） 运算符已从早期版本中的 isnot_distinct_from（） 重命名。以前的名称仍然可用于向后兼容。

属性 sqlalchemy.sql.expression.ColumnElement. is_selectable = False¶

method sqlalchemy.sql.expression.ColumnElement. isnot（other： Any）→ 列运算符¶

继承自ColumnOperators 的 ColumnOperators.isnot（） 方法

实现 IS NOT 运算符。

通常，在与值 None 进行比较时，会自动生成 IS NOT，该值解析为 NULL。但是，如果与某些平台上的布尔值进行比较，则显式使用 IS NOT 可能是可取的。

在 1.4 版本发生变更： is_not（） 运算符已从 isnot（）的 API 中。以前的名称仍然可用于向后兼容。

另请参阅

方法 sqlalchemy.sql.expression.ColumnElement. isnot_distinct_from（other： Any）→ ColumnOperators¶

继承自 ColumnOperators.isnot_distinct_from() ColumnOperators 的方法

实现 IS NOT DISTINCT FROM 运算符。

在大多数平台上呈现 “a IS NOT DISTINCT WITH b”;在某些（例如 SQLite）上可能会呈现“a IS b”。

在 1.4 版本发生变更： is_not_distinct_from（） 运算符已从早期版本中的 isnot_distinct_from（） 重命名。以前的名称仍然可用于向后兼容。

方法 sqlalchemy.sql.expression.ColumnElement. istartswith（other： Any， escape：strNone=None， autoescape： bool = False）→ 列运算符¶

继承自ColumnOperators 的 ColumnOperators.istartswith（）方法

实现 istartswith 运算符，例如 ColumnOperators.startswith（） 的不区分大小写版本。

生成一个 LIKE 表达式，该表达式针对字符串值开头的不敏感匹配项进行测试：

lower(column) LIKE lower(<other>) || '%'

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.istartswith.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.istartswith.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.istartswith.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.istartswith("foo%bar", autoescape=True)
```
将渲染为：
```
lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.istartswith("foo/%bar", escape="^")
```
将渲染为：
```
lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'
```
该参数也可以与 ColumnOperators.istartswith.autoescape ：
```
somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

attribute sqlalchemy.sql.expression.ColumnElement. key：strNone = None¶

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

这通常是指列的 “key” .c 集合，例如 sometable.c[“somekey”] 将返回一个 .key为 “somekey” 的 Column。

方法 sqlalchemy.sql.expression.ColumnElement. label（name：strNone）→ Label[_T]¶

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

这是 label（） 函数的快捷方式。

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

method sqlalchemy.sql.expression.ColumnElement. like（other： Any， escape：strNone=None）→ 列运算符¶

继承自 ColumnOperators 的 ColumnOperators.like（） 方法

实现 like 运算符。

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

a LIKE other

例如：

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

参数

other¶ – 要比较的表达式
转义¶ –

可选的转义字符，将 ESCAPE 关键字，例如：
```
somecolumn.like("foo/%bar", escape="/")
```

另请参阅

method sqlalchemy.sql.expression.ColumnElement. match（other： Any， **kwargs： Any）→ ColumnOperators¶

继承自 ColumnOperators 的 ColumnOperators.match（）方法

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

ColumnOperators.match（） 尝试解析为后端提供的类似 MATCH 的函数或运算符。示例包括：

PostgreSQL - 渲染 x @@ plainto_tsquery（y）

在 2.0 版本发生变更： PostgreSQL 现在使用 plainto_tsquery（） 而不是 to_tsquery（） ;有关与其他表单的兼容性，请参阅全文搜索。
MySQL - 渲染 MATCH (x) AGAINST (y IN BOOLEAN MODE)

另请参阅

match - 具有附加功能的 MySQL 特定构造。
Oracle 数据库 - 呈现 CONTAINS（x， y）
其他后端可能会提供特殊的实现。
没有任何特殊实现的后端会将运算符发出为 “MATCH”。例如，这与 SQLite 兼容。

属性 sqlalchemy.sql.expression.ColumnElement. negation_clause： ColumnElement[bool]¶

方法 sqlalchemy.sql.expression.ColumnElement. not_ilike（other： Any， escape：strNone=None）→ ColumnOperators¶

继承自ColumnOperators 的 ColumnOperators.not_ilike（） 方法

实现 NOT ILIKE 运算符。

这相当于使用 ColumnOperators.ilike（）的 ColumnOperators.ilike（）中，即 ~x.ilike（y）。

在 1.4 版本发生变更： not_ilike（） 运算符已从 notilike（） 的 intent 函数。以前的名称仍然可用于向后兼容。

另请参阅

方法 sqlalchemy.sql.expression.ColumnElement. not_in（other： Any）→ ColumnOperators¶

继承自ColumnOperators 的 ColumnOperators.not_in（） 方法

实现 NOT IN 运算符。

这相当于使用 ColumnOperators.in_（），即 ~x.in_（y）。

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

在 1.4 版本发生变更： not_in（） 运算符从 notin_（） 中。以前的名称仍然可用于向后兼容。

在 1.2 版本发生变更： ColumnOperators.in_（） 和 ColumnOperators.not_in（） 运算符现在默认为空 IN 序列生成 “static” 表达式。

另请参阅

方法 sqlalchemy.sql.expression.ColumnElement. not_like（other： Any， escape：strNone=None）→ ColumnOperators¶

继承自ColumnOperators 的 ColumnOperators.not_like（） 方法

实现 NOT LIKE 运算符。

这相当于使用 ColumnOperators.like（）的 ColumnOperators.like（）中，即 ~x.like（y）。

在 1.4 版本发生变更： not_like（） 运算符已从 notlike（） 的以前的名称仍然可用于向后兼容。

另请参阅

method sqlalchemy.sql.expression.ColumnElement. notilike（other： Any， escape：strNone=None）→ 列运算符¶

继承自ColumnOperators 的 ColumnOperators.notilike（） 方法

实现 NOT ILIKE 运算符。

这相当于使用 ColumnOperators.ilike（）的 ColumnOperators.ilike（）中，即 ~x.ilike（y）。

在 1.4 版本发生变更： not_ilike（） 运算符已从 notilike（） 的 intent 函数。以前的名称仍然可用于向后兼容。

另请参阅

方法 sqlalchemy.sql.expression.ColumnElement. notin_（other： Any）→ ColumnOperators¶

继承自ColumnOperators 的 ColumnOperators.notin_（） 方法

实现 NOT IN 运算符。

这相当于使用 ColumnOperators.in_（），即 ~x.in_（y）。

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

在 1.4 版本发生变更： not_in（） 运算符从 notin_（） 中。以前的名称仍然可用于向后兼容。

在 1.2 版本发生变更： ColumnOperators.in_（） 和 ColumnOperators.not_in（） 运算符现在默认为空 IN 序列生成 “static” 表达式。

另请参阅

method sqlalchemy.sql.expression.ColumnElement. notlike（other： Any， escape：strNone=None）→ 列运算符¶

继承自ColumnOperators 的 ColumnOperators.notlike（） 方法

实现 NOT LIKE 运算符。

这相当于使用 ColumnOperators.like（）的 ColumnOperators.like（）中，即 ~x.like（y）。

在 1.4 版本发生变更： not_like（） 运算符已从 notlike（） 的以前的名称仍然可用于向后兼容。

另请参阅

方法 sqlalchemy.sql.expression.ColumnElement. nulls_first（）→ ColumnOperators¶: 继承自ColumnOperators 的 ColumnOperators.nulls_first（） 方法

针对父对象生成 nulls_first（） 子句。

在 1.4 版本发生变更： nulls_first（） 运算符已从以前版本中的 nullsfirst（） 重命名。以前的名称仍然可用于向后兼容。

方法 sqlalchemy.sql.expression.ColumnElement. nulls_last（）→ ColumnOperators¶: 继承自ColumnOperators 的 ColumnOperators.nulls_last（） 方法

针对父对象生成 nulls_last（） 子句。

在 1.4 版本发生变更： nulls_last（） 运算符已从以前版本中的 nullslast（） 重命名。以前的名称仍然可用于向后兼容。

方法 sqlalchemy.sql.expression.ColumnElement. nullsfirst（）→ ColumnOperators¶: 继承自ColumnOperators 的 ColumnOperators.nullsfirst（） 方法

针对父对象生成 nulls_first（） 子句。

在 1.4 版本发生变更： nulls_first（） 运算符已从以前版本中的 nullsfirst（） 重命名。以前的名称仍然可用于向后兼容。

方法 sqlalchemy.sql.expression.ColumnElement. nullslast（）→ ColumnOperators¶: 继承自 ColumnOperators 的 ColumnOperators.nullslast（）方法

针对父对象生成 nulls_last（） 子句。

在 1.4 版本发生变更： nulls_last（） 运算符已从以前版本中的 nullslast（） 重命名。以前的名称仍然可用于向后兼容。

方法 sqlalchemy.sql.expression.ColumnElement. op（opstring： str， precedence： int = 0， is_comparison： bool = false， return_type：Type[TypeEngine[any]]TypeEngine[any]None=None， python_impl：Callable[...，Any]None=None）→ Callable[[any]， operators []¶

继承自Operators 的 Operators.op（） 方法

生成泛型运算符函数。

例如：

somecolumn.op("*")(5)

生产：

somecolumn * 5

此函数还可用于使按位运算符显式。例如：

somecolumn.op("&")(0xFF)

是 somecolumn 中值的按位 AND。

参数

opstring¶ – 一个字符串，将作为此元素和传递给生成函数的表达式之间的中缀运算符输出。
优先级¶ –

优先级，数据库应应用于 SQL 表达式中的运算符。此整数值充当 SQL 编译器的提示，以了解何时应在特定作周围呈现显式括号。较小的数字将导致表达式在应用于另一个优先级较高的运算符时被括起来。默认值 0 低于除逗号（，）和 AS 运算符之外的所有运算符。值 100 将高于或等于所有运算符，而 -100 将小于或等于所有运算符。

另请参阅

我正在使用 op（）生成自定义运算符，但我的括号没有正确显示 - SQLAlchemy SQL 编译器如何呈现括号的详细说明
is_comparison¶ –

遗产;如果为 True，则该运算符将被视为 “比较” 运算符，即计算结果为布尔值 true/false 值，如 ==、> 等。提供此标志是为了让 ORM 关系可以确定该运算符在自定义连接条件中使用时是比较运算符。

使用 is_comparison 参数将被使用 Operators.bool_op（） 方法;这个更简洁的运算符会自动设置此参数，但也提供正确的 PEP 484 类型支持，因为返回的对象将表示“布尔”数据类型，即 BinaryExpression[bool]。
return_type¶—— TypeEngine 类或对象，它将 force 此运算符生成的表达式的返回类型属于该类型。默认情况下，指定 Operators.op.is_comparison将解析为 Boolean 的 Boolean 和那些不 boolean 的 Boolean 将与左侧作数的类型相同。
python_impl¶ –

一个可选的 Python 函数，该函数可以计算两个 Python 值，其工作方式与此运算符在数据库服务器上运行时的工作方式相同。对于 Python 内部 SQL 表达式评估函数（例如 ORM 混合属性）以及用于在多行更新或删除后匹配会话中的对象的 ORM“评估器”非常有用。

例如：
```
>>> expr = column("x").op("+", python_impl=lambda a, b: a + b)("y")
```
上述表达式的运算符也适用于非 SQL 的 left 和 right 对象：
```
>>> expr.operator(5, 10)
15
```
2.0 版的新Function。

另请参阅

ColumnOperators.regexp_replace()

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

method sqlalchemy.sql.expression.ColumnElement. operate（op： OperatorType， *other： Any， **kwargs： Any→ ColumnElement （列元素）[任意]¶

对参数进行作。

这是最低级别的作，加注 NotImplementedError 的 MethodS 错误。

在子类上覆盖 this 可以允许将通用行为应用于所有作。例如，重写 ColumnOperators 要将 func.lower（） 应用于左侧和右侧：

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

参数

op¶- 运算符可调用。
other¶ ——作的 'other' 端。对于大多数作，将是单个标量。
**kwargs¶ —— 修饰符。这些可以通过特殊运算符（如 ColumnOperators.contains（）））传递。

method sqlalchemy.sql.expression.ColumnElement. params（_ClauseElement__optionaldict：Mapping[str，Any]None=None， **kwargs： Any）→ Self¶

继承自ClauseElement 的 ClauseElement.params（） 方法

返回替换了 bindparam（） 元素的副本。

返回此 ClauseElement 的副本，其中包含 bindparam（） 元素替换为从给定字典中获取的值：

>>> clause = column("x") + bindparam("foo")
>>> print(clause.compile().params)
{'foo':None}
>>> print(clause.params({"foo": 7}).compile().params)
{'foo':7}

属性 sqlalchemy.sql.expression.ColumnElement. primary_key： bool = False¶

属性 sqlalchemy.sql.expression.ColumnElement. proxy_set：util.generic_fn_descriptor[FrozenSet[Any]]¶

我们代理的所有列的集合

从 2.0 开始，这是显式取消注释的列。以前，它实际上是取消注释的列，但并未强制执行。如果可能的话，带 Comments 的列基本上不应该进入 SETS，因为它们的哈希行为非常不稳定。

方法 sqlalchemy.sql.expression.ColumnElement. regexp_match（pattern： Any， flags：strNone=None）→ ColumnOperators¶

继承自 ColumnOperators.regexp_match() 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 Database、PostgreSQL、MySQL 和 MariaDB 实施正则表达式支持。SQLite 提供部分支持。第三方方言之间的支持可能会有所不同。

参数

pattern¶– 正则表达式模式字符串或列子句。
flags¶– 要应用的任何正则表达式字符串标志，仅作为纯 Python 字符串传递。这些标志是特定于后端的。一些后端，如 PostgreSQL 和 MariaDB，也可以将标志指定为模式的一部分。在 PostgreSQL 中使用忽略大小写标志 'i' 时，将使用忽略大小写正则表达式匹配运算符 ~* 或 ！~*。

在 1.4 版本加入.

在 1.4.48 版本发生变更： 2.0.18 请注意，由于实现错误，除了纯 Python 字符串之外，“flags”参数以前还接受 SQL 表达式对象，例如列表达式。此实现无法正确使用缓存，因此已被删除;只应为 “flags” 参数传递字符串，因为这些标志在 SQL 表达式中呈现为文本内联值。

另请参阅

方法 sqlalchemy.sql.expression.ColumnElement. regexp_replace（pattern： Any， replacement： Any， flags：strNone=None）→ ColumnOperators¶

继承自 ColumnOperators.regexp_replace() ColumnOperators 的方法

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

例如：

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

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

目前为 Oracle Database、PostgreSQL、MySQL 8 或更高版本以及 MariaDB 实施了正则表达式替换支持。第三方方言之间的支持可能会有所不同。

参数

pattern¶– 正则表达式模式字符串或列子句。
pattern¶– 替换字符串或 column 子句。
flags¶– 要应用的任何正则表达式字符串标志，仅作为纯 Python 字符串传递。这些标志是特定于后端的。一些后端，如 PostgreSQL 和 MariaDB，也可以将标志指定为模式的一部分。

在 1.4 版本加入.

在 1.4.48 版本发生变更： 2.0.18 请注意，由于实现错误，除了纯 Python 字符串之外，“flags”参数以前还接受 SQL 表达式对象，例如列表达式。此实现无法正确使用缓存，因此已被删除;只应为 “flags” 参数传递字符串，因为这些标志在 SQL 表达式中呈现为文本内联值。

另请参阅

ColumnOperators.regexp_match()

方法 sqlalchemy.sql.expression.ColumnElement. reverse_operate（op： OperatorType， other： Any， **kwargs： Any→ ColumnElement[任意]¶

Reverse 对参数进行作。

用法与 operate（） 相同。

方法 sqlalchemy.sql.expression.ColumnElement. self_group（against：OperatorTypeNone=None）→ ColumnElement[Any]¶

将 'grouping' 应用于此 ClauseElement。

此方法被 subclasses 覆盖以返回 “grouping” 结构，即括号。特别是，当它被 “binary” 表达式用于在放入更大的表达式时提供围绕自身的分组，以及 select（） 构造 select（） 的（请注意，子查询通常应使用 Select.alias（） 方法创建，因为许多平台需要命名嵌套的 SELECT 语句）。

由于表达式是组合在一起的，因此 self_group（） 是自动的 - 最终用户代码永远不需要直接使用此方法。请注意，SQLAlchemy 的子句构造考虑了运算符优先级 - 因此可能不需要括号，例如，在像 x OR （y AND z） 这样的表达式中 - AND 优先于 OR。

的 base self_group（） 方法 子句元素 只返回 self。

方法 sqlalchemy.sql.expression.ColumnElement. shares_lineage（othercolumn： ColumnElement[Any]）→ bool¶: 如果给定的 ColumnElement 具有此 ColumnElement 的共同上级。

方法 sqlalchemy.sql.expression.ColumnElement. startswith（other： Any， escape：strNone=None， autoescape： bool = False）→ 列运算符¶

继承自 ColumnOperators 的 ColumnOperators.startswith（）方法

实现 startswith 运算符。

生成一个 LIKE 表达式，该表达式针对字符串值开头的匹配项进行测试：

column LIKE <other> || '%'

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.startswith.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.startswith.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.startswith.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.startswith("foo%bar", autoescape=True)
```
将渲染为：
```
somecolumn LIKE :param || '%' ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.startswith("foo/%bar", escape="^")
```
将渲染为：
```
somecolumn LIKE :param || '%' ESCAPE '^'
```
该参数也可以与 ColumnOperators.startswith.autoescape ：
```
somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

属性 sqlalchemy.sql.expression.ColumnElement. stringify_dialect = 'default'¶

属性 sqlalchemy.sql.expression.ColumnElement. supports_execution = False¶

属性 sqlalchemy.sql.expression.ColumnElement. timetuple： Literal[None] = None¶: 继承自ColumnOperators 的 ColumnOperators.timetuple属性

Hack 允许在 LHS 上比较日期时间对象。

attribute sqlalchemy.sql.expression.ColumnElement. type： TypeEngine[_T]¶

方法 sqlalchemy.sql.expression.ColumnElement. unique_params（_ClauseElement__optionaldict：Dict[str，Any]None=None， **kwargs： Any）→ Self¶

继承自ClauseElement 的 ClauseElement.unique_params（） 方法

返回替换了 bindparam（） 元素的副本。

与 ClauseElement.params（） 功能相同，但添加了 unique=True 添加到受影响的绑定参数中，以便多个语句可以使用。

属性 sqlalchemy.sql.expression.ColumnElement. uses_inspection = True¶

sqlalchemy.sql.expression 中。ColumnExpressionArgument¶

通用的 “column expression” 参数。

2.0.13 新版功能.

此类型用于通常表示单个 SQL 列表达式的“列”类型的表达式，包括 ColumnElement，以及将具有 __clause_element__（） 的 ORM 映射属性方法。

类 sqlalchemy.sql.expression 中。列运算符¶

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

默认情况下，所有方法都会调用 operate（） 或 reverse_operate（），从 Python 内置 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

列运算符

PropComparator （属性比较器）

成员

__add__（）， __and__（）， __eq__（）， __floordiv__（）， __ge__（）， __getitem__（）， __gt__（）， __hash__（）， __invert__（）， __le__（）， __lshift__（）， __lt__（）， __mod__（）， __mul__（）， __ne__（）， __neg__（）， __or__（）， __radd__（）， __rfloordiv__（）， __rmod__（）， __rmul__（）， __rshift__（）， __rsub__（）， __rtruediv__（）， __sa_operate__（）， __sub__（）， __truediv__（）， all_（）、 any_（）、 asc（）、 between（）、 bitwise_and（）、 bitwise_lshift（）、 bitwise_not（）、 bitwise_or（）、 bitwise_rshift（）、 bitwise_xor（）、 bool_op（）、 collate（）、 concat（）、 contains（）、 desc（）、 distinct（）、 endswith（）、 icontains（）、 iendswith（）、 ilike（）、 in_（）、 is_（）、 is_distinct_from（）、 is_not（）、 is_not_distinct_from（）、 isnot（）， isnot_distinct_from（）， istartswith（）， like（）， match（）， not_ilike（）， not_in（）， not_like（）， notilike（）， notin_（）， notlike（）， nulls_first（），nulls_last（）， nullsfirst（）， nullslast（）， op（）， operate（）， regexp_match（）， regexp_replace（）， reverse_operate（）， startswith（）， timetuple

类签名

类 sqlalchemy.sql.expression.ColumnOperators （ sqlalchemy.sql.expression.Operators ）

方法 sqlalchemy.sql.expression.ColumnOperators. __add__（other： Any）→ ColumnOperators¶

实现 + 运算符。

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

method sqlalchemy.sql.expression.ColumnOperators. __and__（other： Any）→ 运算符¶

继承自 sqlalchemy.sql.expression.Operators.__and__ Operators 的方法

实施 & 运算符。

与 SQL 表达式一起使用时，将生成 AND 运算，相当于 and_（）中，即：

a & b

等效于：

from sqlalchemy import and_

and_(a, b)

使用时应小心并考虑运算符的优先顺序;&运算符具有最高的优先级。如果作数包含其他子表达式，则应将其括在括号中：

(a == 2) & (b == 4)

方法 sqlalchemy.sql.expression.ColumnOperators. __eq__（other： Any）→ ColumnOperators¶

实现 == 运算符。

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

方法 sqlalchemy.sql.expression.ColumnOperators. __floordiv__（other： Any）→ ColumnOperators¶

实现 Operator。

在列上下文中，生成子句 a / b，它与 “truediv” 相同，但将结果类型视为整数。

2.0 版的新Function。

方法 sqlalchemy.sql.expression.ColumnOperators. __ge__（other： Any）→ ColumnOperators¶

实现 >= 运算符。

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

方法 sqlalchemy.sql.expression.ColumnOperators. __getitem__（index： Any）→ ColumnOperators¶

实现 [] 运算符。

这可以由某些特定于数据库的类型（如 PostgreSQL、ARRAY 和 HSTORE）使用。

方法 sqlalchemy.sql.expression.ColumnOperators. __gt__（other： Any）→ ColumnOperators¶

实现 > 运算符。

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

方法 sqlalchemy.sql.expression.ColumnOperators. __hash__（）¶: 返回 hash（self）。

方法 sqlalchemy.sql.expression.ColumnOperators. __invert__（）→ 运算符¶

继承自 sqlalchemy.sql.expression.Operators.__invert__ Operators 的方法

实现 ~ 运算符。

与 SQL 表达式一起使用时，会生成 NOT作，相当于 not_（） 中，即：

~a

等效于：

from sqlalchemy import not_

not_(a)

方法 sqlalchemy.sql.expression.ColumnOperators. __le__（other： Any）→ ColumnOperators¶

实现 <= 运算符。

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

方法 sqlalchemy.sql.expression.ColumnOperators. __lshift__（other： Any）→ ColumnOperators¶

实现 << 运算符。

SQLAlchemy 核心不使用，这是为希望使用 << 作为扩展点的自定义作系统提供的。

方法 sqlalchemy.sql.expression.ColumnOperators. __lt__（other： Any）→ ColumnOperators¶

实现 < 运算符。

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

方法 sqlalchemy.sql.expression.ColumnOperators. __mod__（other： Any）→ ColumnOperators¶

实现 % 运算符。

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

方法 sqlalchemy.sql.expression.ColumnOperators. __mul__（other： Any）→ ColumnOperators¶

实现 * 运算符。

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

方法 sqlalchemy.sql.expression.ColumnOperators. __ne__（other： Any）→ ColumnOperators¶

实现 ！= 运算符。

在列上下文中，生成子句 a ！= b。如果目标是 None，则生成 IS NOT NULL。

方法 sqlalchemy.sql.expression.ColumnOperators. __neg__（）→ ColumnOperators¶

实现 - 运算符。

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

method sqlalchemy.sql.expression.ColumnOperators. __or__（other： Any）→ 运算符¶

继承自 sqlalchemy.sql.expression.Operators.__or__ Operators 的方法

实现 | 运算符。

与 SQL 表达式一起使用时，将生成 OR 运算，相当于 or_（）），即：

a | b

等效于：

from sqlalchemy import or_

or_(a, b)

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

(a == 2) | (b == 4)

方法 sqlalchemy.sql.expression.ColumnOperators. __radd__（other： Any）→ ColumnOperators¶

反向实现 + 运算符。

请参阅 ColumnOperators.__add__（）。

方法 sqlalchemy.sql.expression.ColumnOperators. __rfloordiv__（other： Any）→ ColumnOperators¶

反向实现 Operator。

请参阅 ColumnOperators.__floordiv__() 。

方法 sqlalchemy.sql.expression.ColumnOperators. __rmod__（other： Any）→ ColumnOperators¶

反向实现 % 运算符。

请参阅 ColumnOperators.__mod__（）。

方法 sqlalchemy.sql.expression.ColumnOperators. __rmul__（other： Any）→ ColumnOperators¶

反向实现 * 运算符。

参见 ColumnOperators.__mul__（）。

方法 sqlalchemy.sql.expression.ColumnOperators. __rshift__（other： Any）→ ColumnOperators¶

实现 >> 运算符。

SQLAlchemy 核心不使用，这是为希望使用 >> 作为扩展点的自定义作系统提供的。

方法 sqlalchemy.sql.expression.ColumnOperators. __rsub__（other： Any）→ ColumnOperators¶

反向实现 - 运算符。

参见 ColumnOperators.__sub__（）。

方法 sqlalchemy.sql.expression.ColumnOperators. __rtruediv__（other： Any）→ ColumnOperators¶

反向实现 / 运算符。

请参阅 ColumnOperators.__truediv__（）。

方法 sqlalchemy.sql.expression.ColumnOperators. __sa_operate__（op： OperatorType， *other： Any， **kwargs： Any→ 运营商¶

继承自 sqlalchemy.sql.expression.Operators.__sa_operate__ Operators 的方法

对参数进行作。

这是最低级别的作，加注 NotImplementedError 的 MethodS 错误。

在子类上覆盖 this 可以允许将通用行为应用于所有作。例如，重写 ColumnOperators 要将 func.lower（） 应用于左侧和右侧：

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

参数

op¶- 运算符可调用。
other¶ ——作的 'other' 端。对于大多数作，将是单个标量。
**kwargs¶ —— 修饰符。这些可以通过特殊运算符（如 ColumnOperators.contains（）））传递。

方法 sqlalchemy.sql.expression.ColumnOperators. __sub__（other： Any）→ ColumnOperators¶

实现 - 运算符。

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

方法 sqlalchemy.sql.expression.ColumnOperators. __truediv__（other： Any）→ ColumnOperators¶

实现 / 运算符。

在列上下文中，生成子句 a / b，并将结果类型视为 numeric。

在 2.0 版更改：针对两个整数的 truediv 运算符现在被视为返回数值。特定后端上的行为可能会有所不同。

方法 sqlalchemy.sql.expression.ColumnOperators. all_（）→ ColumnOperators¶

针对父对象生成 all_（） 子句。

有关示例，请参阅 all_（） 的文档。

注意

一定不要混淆较新的 ColumnOperators.all_（） 方法替换为旧版版本，则 Comparator.all（） 方法，它使用不同的调用样式。

方法 sqlalchemy.sql.expression.ColumnOperators. any_（）→ ColumnOperators¶

针对父对象生成 any_（） 子句。

有关示例，请参阅 any_（） 的文档。

注意

一定不要混淆较新的 ColumnOperators.any_（） 方法替换为旧版版本，则 Comparator.any（） 方法，它使用不同的调用样式。

方法 sqlalchemy.sql.expression.ColumnOperators. asc（）→ ColumnOperators¶: 针对父对象生成 asc（） 子句。

method sqlalchemy.sql.expression.ColumnOperators. between（cleft：任意， cright：任意， 对称： bool = False）→ ColumnOperators¶: 在给定下限和上限范围的情况下，针对父对象生成一个 between（） 子句。

方法 sqlalchemy.sql.expression.ColumnOperators. bitwise_and（other： Any）→ ColumnOperators¶: 产生一个按位的 AND 运算，通常通过 & 算子。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnOperators. bitwise_lshift（other： Any）→ ColumnOperators¶: 产生按位 LSHIFT 运算，通常通过 << 算子。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnOperators. bitwise_not（）→ ColumnOperators¶: 产生一个按位的 NOT 运算，通常通过 ~ 算子。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnOperators. bitwise_or（other： Any）→ ColumnOperators¶: 生成按位 OR 运算，通常通过 | 算子。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnOperators. bitwise_rshift（other： Any）→ ColumnOperators¶: 生成按位 RSHIFT 运算，通常通过 >> 算子。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnOperators. bitwise_xor（other： Any）→ ColumnOperators¶: 生成按位 XOR 运算，通常通过 ^ 运算符，或者 # 表示 PostgreSQL。

2.0.2 新版功能.

另请参阅

按位运算符

方法 sqlalchemy.sql.expression.ColumnOperators. bool_op（opstring： str， precedence： int = 0， python_impl：Callable[[...]，Any]None=None）→ Callable[[any]，运算符]¶

继承自Operators 的 Operators.bool_op（） 方法

返回自定义布尔运算符。

此方法是调用 Operators.op（） 并将 Operators.op.is_comparison flag 替换为 True。使用 Operators.bool_op（） 的主要优势是，当使用列构造时，返回的 expression 将用于 PEP 484 目的。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. collate（collation： str）→ ColumnOperators¶: 给定排序规则字符串，针对父对象生成 collate（） 子句。

另请参阅

collate（）

method sqlalchemy.sql.expression.ColumnOperators. concat（other： Any）→ ColumnOperators¶

实现 'concat' 运算符。

在列上下文中，生成子句 a || b，或在 MySQL 上使用 concat（） 运算符。

method sqlalchemy.sql.expression.ColumnOperators. contains（other： Any， **kw： Any）→ ColumnOperators¶

实现 'contains' 运算符。

生成一个 LIKE 表达式，该表达式针对字符串值中间的匹配项进行测试：

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

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.contains.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.contains.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.contains.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.contains("foo%bar", autoescape=True)
```
将渲染为：
```
somecolumn LIKE '%' || :param || '%' ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.contains("foo/%bar", escape="^")
```
将渲染为：
```
somecolumn LIKE '%' || :param || '%' ESCAPE '^'
```
该参数也可以与 ColumnOperators.contains.autoescape ：
```
somecolumn.contains("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. desc（）→ ColumnOperators¶: 针对父对象生成 desc（） 子句。

method sqlalchemy.sql.expression.ColumnOperators. distinct（）→ 列运算符¶: 针对父对象生成 distinct（） 子句。

method sqlalchemy.sql.expression.ColumnOperators. endswith（other： Any， escape：strNone=None， autoescape： bool = False）→ 列运算符¶

实现 'endswith' 运算符。

生成一个 LIKE 表达式，该表达式针对字符串值末尾的匹配项进行测试：

column LIKE '%' || <other>

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.endswith.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.endswith.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.endswith.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.endswith("foo%bar", autoescape=True)
```
将渲染为：
```
somecolumn LIKE '%' || :param ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.endswith("foo/%bar", escape="^")
```
将渲染为：
```
somecolumn LIKE '%' || :param ESCAPE '^'
```
该参数也可以与 ColumnOperators.endswith.autoescape ：
```
somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. icontains（other： Any， **kw： Any）→ ColumnOperators¶

实现 icontains 运算符，例如 ColumnOperators.contains（） 的不区分大小写版本。

生成一个 LIKE 表达式，该表达式针对字符串值中间的不敏感匹配项进行测试：

lower(column) LIKE '%' || lower(<other>) || '%'

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.icontains.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.icontains.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.icontains.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.icontains("foo%bar", autoescape=True)
```
将渲染为：
```
lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.icontains("foo/%bar", escape="^")
```
将渲染为：
```
lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'
```
该参数也可以与 ColumnOperators.contains.autoescape ：
```
somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

method sqlalchemy.sql.expression.ColumnOperators. iendswith（other： Any， escape：strNone=None， autoescape： bool = False）→ 列运算符¶

实现 iendswith 运算符，例如 ColumnOperators.endswith（） 的不区分大小写版本。

生成一个 LIKE 表达式，该表达式针对字符串值末尾的不敏感匹配项进行测试：

lower(column) LIKE '%' || lower(<other>)

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.iendswith.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.iendswith.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.iendswith.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.iendswith("foo%bar", autoescape=True)
```
将渲染为：
```
lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.iendswith("foo/%bar", escape="^")
```
将渲染为：
```
lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'
```
该参数也可以与 ColumnOperators.iendswith.autoescape ：
```
somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. ilike（other： Any， escape：strNone=None）→ 列运算符¶

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

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

lower(a) LIKE lower(other)

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

a ILIKE other

例如：

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

参数

other¶ – 要比较的表达式
转义¶ –

可选的转义字符，将 ESCAPE 关键字，例如：
```
somecolumn.ilike("foo/%bar", escape="/")
```

另请参阅

ColumnOperators.is_not（）

方法 sqlalchemy.sql.expression.ColumnOperators. in_（other： Any）→ ColumnOperators¶

实现 in 运算符。

在列上下文中，生成子句列 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_([]))
```
在此调用形式中，表达式呈现 “empty set” 表达式。这些表达式是针对各个后端量身定制的，通常尝试获取空的 SELECT 语句作为子查询。例如在 SQLite 上，表达式为：
```
WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
在 1.4 版本发生变更：空的 IN 表达式现在在所有情况下都使用执行时生成的 SELECT 子查询。
如果绑定参数包含 bindparam.expanding 标志，则可以使用该参数，例如 bindparam（）：
```
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 版本加入：添加了 “expanding” 绑定参数

如果传递了空列表，则会呈现特定于正在使用的数据库的特殊“空列表”表达式。在 SQLite 上，这将是：
```
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
在 1.3 版本加入： “expanding” 绑定参数现在支持空列表

select（） 结构，通常是相关的标量 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¶ —— 一个字面值列表，一个 select（） 构造，或者包含 bindparam.expanding 标志设置为 True。

方法 sqlalchemy.sql.expression.ColumnOperators. is_（other： Any）→ ColumnOperators¶

实现 IS 运算符。

通常，在与值 None 进行比较时，会自动生成 IS，该值解析为 NULL。但是，如果与某些平台上的布尔值进行比较，则显式使用 IS 可能是可取的。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. is_distinct_from（other： Any）→ ColumnOperators¶

实现 IS DISTINCT FROM 运算符。

在大多数平台上呈现 “a IS DISTINCT FROM b”;在某些（例如 SQLite）上可能会呈现“a IS NOT b”。

方法 sqlalchemy.sql.expression.ColumnOperators. is_not（other： Any）→ ColumnOperators¶

实现 IS NOT 运算符。

通常，在与值 None 进行比较时，会自动生成 IS NOT，该值解析为 NULL。但是，如果与某些平台上的布尔值进行比较，则显式使用 IS NOT 可能是可取的。

在 1.4 版本发生变更： is_not（） 运算符已从 isnot（）的 API 中。以前的名称仍然可用于向后兼容。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. is_not_distinct_from（other： Any）→ ColumnOperators¶

实现 IS NOT DISTINCT FROM 运算符。

在大多数平台上呈现 “a IS NOT DISTINCT WITH b”;在某些（例如 SQLite）上可能会呈现“a IS b”。

在 1.4 版本发生变更： is_not_distinct_from（） 运算符已从早期版本中的 isnot_distinct_from（） 重命名。以前的名称仍然可用于向后兼容。

method sqlalchemy.sql.expression.ColumnOperators. isnot（other： Any）→ 列运算符¶

实现 IS NOT 运算符。

通常，在与值 None 进行比较时，会自动生成 IS NOT，该值解析为 NULL。但是，如果与某些平台上的布尔值进行比较，则显式使用 IS NOT 可能是可取的。

在 1.4 版本发生变更： is_not（） 运算符已从 isnot（）的 API 中。以前的名称仍然可用于向后兼容。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. isnot_distinct_from（other： Any）→ ColumnOperators¶

实现 IS NOT DISTINCT FROM 运算符。

在大多数平台上呈现 “a IS NOT DISTINCT WITH b”;在某些（例如 SQLite）上可能会呈现“a IS b”。

在 1.4 版本发生变更： is_not_distinct_from（） 运算符已从早期版本中的 isnot_distinct_from（） 重命名。以前的名称仍然可用于向后兼容。

方法 sqlalchemy.sql.expression.ColumnOperators. istartswith（other： Any， escape：strNone=None， autoescape： bool = False）→ 列运算符¶

实现 istartswith 运算符，例如 ColumnOperators.startswith（） 的不区分大小写版本。

生成一个 LIKE 表达式，该表达式针对字符串值开头的不敏感匹配项进行测试：

lower(column) LIKE lower(<other>) || '%'

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.istartswith.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.istartswith.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.istartswith.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.istartswith("foo%bar", autoescape=True)
```
将渲染为：
```
lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.istartswith("foo/%bar", escape="^")
```
将渲染为：
```
lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'
```
该参数也可以与 ColumnOperators.istartswith.autoescape ：
```
somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

method sqlalchemy.sql.expression.ColumnOperators. like（other： Any， escape：strNone=None）→ 列运算符¶

实现 like 运算符。

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

a LIKE other

例如：

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

参数

other¶ – 要比较的表达式
转义¶ –

可选的转义字符，将 ESCAPE 关键字，例如：
```
somecolumn.like("foo/%bar", escape="/")
```

另请参阅

method sqlalchemy.sql.expression.ColumnOperators. match（other： Any， **kwargs： Any）→ ColumnOperators¶

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

ColumnOperators.match（） 尝试解析为后端提供的类似 MATCH 的函数或运算符。示例包括：

PostgreSQL - 渲染 x @@ plainto_tsquery（y）

在 2.0 版本发生变更： PostgreSQL 现在使用 plainto_tsquery（） 而不是 to_tsquery（） ;有关与其他表单的兼容性，请参阅全文搜索。
MySQL - 渲染 MATCH (x) AGAINST (y IN BOOLEAN MODE)

另请参阅

match - 具有附加功能的 MySQL 特定构造。
Oracle 数据库 - 呈现 CONTAINS（x， y）
其他后端可能会提供特殊的实现。
没有任何特殊实现的后端会将运算符发出为 “MATCH”。例如，这与 SQLite 兼容。

方法 sqlalchemy.sql.expression.ColumnOperators. not_ilike（other： Any， escape：strNone=None）→ ColumnOperators¶

实现 NOT ILIKE 运算符。

这相当于使用 ColumnOperators.ilike（）的 ColumnOperators.ilike（）中，即 ~x.ilike（y）。

在 1.4 版本发生变更： not_ilike（） 运算符已从 notilike（） 的 intent 函数。以前的名称仍然可用于向后兼容。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. not_in（other： Any）→ ColumnOperators¶

实现 NOT IN 运算符。

这相当于使用 ColumnOperators.in_（），即 ~x.in_（y）。

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

在 1.4 版本发生变更： not_in（） 运算符从 notin_（） 中。以前的名称仍然可用于向后兼容。

在 1.2 版本发生变更： ColumnOperators.in_（） 和 ColumnOperators.not_in（） 运算符现在默认为空 IN 序列生成 “static” 表达式。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. not_like（other： Any， escape：strNone=None）→ ColumnOperators¶

实现 NOT LIKE 运算符。

这相当于使用 ColumnOperators.like（）的 ColumnOperators.like（）中，即 ~x.like（y）。

在 1.4 版本发生变更： not_like（） 运算符已从 notlike（） 的以前的名称仍然可用于向后兼容。

另请参阅

method sqlalchemy.sql.expression.ColumnOperators. notilike（other： Any， escape：strNone=None）→ 列运算符¶

实现 NOT ILIKE 运算符。

这相当于使用 ColumnOperators.ilike（）的 ColumnOperators.ilike（）中，即 ~x.ilike（y）。

在 1.4 版本发生变更： not_ilike（） 运算符已从 notilike（） 的 intent 函数。以前的名称仍然可用于向后兼容。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. notin_（other： Any）→ ColumnOperators¶

实现 NOT IN 运算符。

这相当于使用 ColumnOperators.in_（），即 ~x.in_（y）。

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

在 1.4 版本发生变更： not_in（） 运算符从 notin_（） 中。以前的名称仍然可用于向后兼容。

在 1.2 版本发生变更： ColumnOperators.in_（） 和 ColumnOperators.not_in（） 运算符现在默认为空 IN 序列生成 “static” 表达式。

另请参阅

method sqlalchemy.sql.expression.ColumnOperators. notlike（other： Any， escape：strNone=None）→ 列运算符¶

实现 NOT LIKE 运算符。

这相当于使用 ColumnOperators.like（）的 ColumnOperators.like（）中，即 ~x.like（y）。

在 1.4 版本发生变更： not_like（） 运算符已从 notlike（） 的以前的名称仍然可用于向后兼容。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. nulls_first（）→ ColumnOperators¶: 针对父对象生成 nulls_first（） 子句。

在 1.4 版本发生变更： nulls_first（） 运算符已从以前版本中的 nullsfirst（） 重命名。以前的名称仍然可用于向后兼容。

方法 sqlalchemy.sql.expression.ColumnOperators. nulls_last（）→ ColumnOperators¶: 针对父对象生成 nulls_last（） 子句。

在 1.4 版本发生变更： nulls_last（） 运算符已从以前版本中的 nullslast（） 重命名。以前的名称仍然可用于向后兼容。

方法 sqlalchemy.sql.expression.ColumnOperators. nullsfirst（）→ ColumnOperators¶: 针对父对象生成 nulls_first（） 子句。

在 1.4 版本发生变更： nulls_first（） 运算符已从以前版本中的 nullsfirst（） 重命名。以前的名称仍然可用于向后兼容。

方法 sqlalchemy.sql.expression.ColumnOperators. nullslast（）→ ColumnOperators¶: 针对父对象生成 nulls_last（） 子句。

在 1.4 版本发生变更： nulls_last（） 运算符已从以前版本中的 nullslast（） 重命名。以前的名称仍然可用于向后兼容。

方法 sqlalchemy.sql.expression.ColumnOperators. op（opstring： str， precedence： int = 0， is_comparison： bool = false， return_type：Type[TypeEngine[any]]TypeEngine[any]None=None， python_impl：Callable[...，Any]None=None）→ Callable[[any]， operators []¶

继承自Operators 的 Operators.op（） 方法

生成泛型运算符函数。

例如：

somecolumn.op("*")(5)

生产：

somecolumn * 5

此函数还可用于使按位运算符显式。例如：

somecolumn.op("&")(0xFF)

是 somecolumn 中值的按位 AND。

参数

opstring¶ – 一个字符串，将作为此元素和传递给生成函数的表达式之间的中缀运算符输出。
优先级¶ –

优先级，数据库应应用于 SQL 表达式中的运算符。此整数值充当 SQL 编译器的提示，以了解何时应在特定作周围呈现显式括号。较小的数字将导致表达式在应用于另一个优先级较高的运算符时被括起来。默认值 0 低于除逗号（，）和 AS 运算符之外的所有运算符。值 100 将高于或等于所有运算符，而 -100 将小于或等于所有运算符。

另请参阅

我正在使用 op（）生成自定义运算符，但我的括号没有正确显示 - SQLAlchemy SQL 编译器如何呈现括号的详细说明
is_comparison¶ –

遗产;如果为 True，则该运算符将被视为 “比较” 运算符，即计算结果为布尔值 true/false 值，如 ==、> 等。提供此标志是为了让 ORM 关系可以确定该运算符在自定义连接条件中使用时是比较运算符。

使用 is_comparison 参数将被使用 Operators.bool_op（） 方法;这个更简洁的运算符会自动设置此参数，但也提供正确的 PEP 484 类型支持，因为返回的对象将表示“布尔”数据类型，即 BinaryExpression[bool]。
return_type¶—— TypeEngine 类或对象，它将 force 此运算符生成的表达式的返回类型属于该类型。默认情况下，指定 Operators.op.is_comparison将解析为 Boolean 的 Boolean 和那些不 boolean 的 Boolean 将与左侧作数的类型相同。
python_impl¶ –

一个可选的 Python 函数，该函数可以计算两个 Python 值，其工作方式与此运算符在数据库服务器上运行时的工作方式相同。对于 Python 内部 SQL 表达式评估函数（例如 ORM 混合属性）以及用于在多行更新或删除后匹配会话中的对象的 ORM“评估器”非常有用。

例如：
```
>>> expr = column("x").op("+", python_impl=lambda a, b: a + b)("y")
```
上述表达式的运算符也适用于非 SQL 的 left 和 right 对象：
```
>>> expr.operator(5, 10)
15
```
2.0 版的新Function。

另请参阅

ColumnOperators.regexp_replace()

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

method sqlalchemy.sql.expression.ColumnOperators. operate（op： OperatorType， *other： Any， **kwargs： Any→ 运营商¶

继承自Operators 的 Operators.operate（） 方法

对参数进行作。

这是最低级别的作，加注 NotImplementedError 的 MethodS 错误。

在子类上覆盖 this 可以允许将通用行为应用于所有作。例如，重写 ColumnOperators 要将 func.lower（） 应用于左侧和右侧：

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

参数

op¶- 运算符可调用。
other¶ ——作的 'other' 端。对于大多数作，将是单个标量。
**kwargs¶ —— 修饰符。这些可以通过特殊运算符（如 ColumnOperators.contains（）））传递。

方法 sqlalchemy.sql.expression.ColumnOperators. regexp_match（pattern： Any， flags：strNone=None）→ 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 Database、PostgreSQL、MySQL 和 MariaDB 实施正则表达式支持。SQLite 提供部分支持。第三方方言之间的支持可能会有所不同。

参数

pattern¶– 正则表达式模式字符串或列子句。
flags¶– 要应用的任何正则表达式字符串标志，仅作为纯 Python 字符串传递。这些标志是特定于后端的。一些后端，如 PostgreSQL 和 MariaDB，也可以将标志指定为模式的一部分。在 PostgreSQL 中使用忽略大小写标志 'i' 时，将使用忽略大小写正则表达式匹配运算符 ~* 或 ！~*。

在 1.4 版本加入.

在 1.4.48 版本发生变更： 2.0.18 请注意，由于实现错误，除了纯 Python 字符串之外，“flags”参数以前还接受 SQL 表达式对象，例如列表达式。此实现无法正确使用缓存，因此已被删除;只应为 “flags” 参数传递字符串，因为这些标志在 SQL 表达式中呈现为文本内联值。

另请参阅

方法 sqlalchemy.sql.expression.ColumnOperators. regexp_replace（pattern： Any， replacement： Any， flags：strNone=None）→ ColumnOperators¶

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

例如：

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

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

目前为 Oracle Database、PostgreSQL、MySQL 8 或更高版本以及 MariaDB 实施了正则表达式替换支持。第三方方言之间的支持可能会有所不同。

参数

pattern¶– 正则表达式模式字符串或列子句。
pattern¶– 替换字符串或 column 子句。
flags¶– 要应用的任何正则表达式字符串标志，仅作为纯 Python 字符串传递。这些标志是特定于后端的。一些后端，如 PostgreSQL 和 MariaDB，也可以将标志指定为模式的一部分。

在 1.4 版本加入.

在 1.4.48 版本发生变更： 2.0.18 请注意，由于实现错误，除了纯 Python 字符串之外，“flags”参数以前还接受 SQL 表达式对象，例如列表达式。此实现无法正确使用缓存，因此已被删除;只应为 “flags” 参数传递字符串，因为这些标志在 SQL 表达式中呈现为文本内联值。

另请参阅

ColumnOperators.regexp_match()

方法 sqlalchemy.sql.expression.ColumnOperators. reverse_operate（op： OperatorType， other： Any， **kwargs： Any）→ 运算符¶

继承自Operators 的 Operators.reverse_operate（） 方法

Reverse 对参数进行作。

用法与 operate（） 相同。

方法 sqlalchemy.sql.expression.ColumnOperators. startswith（other： Any， escape：strNone=None， autoescape： bool = False）→ 列运算符¶

实现 startswith 运算符。

生成一个 LIKE 表达式，该表达式针对字符串值开头的匹配项进行测试：

column LIKE <other> || '%'

例如：

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

由于运算符使用 LIKE、通配符存在于 <other> 表达式中的 “%” 和 “_” 的行为也类似于通配符。对于 Literals 字符串值，可以将 ColumnOperators.startswith.autoescape 该标志设置为 True 以对出现这些值字符，以便它们与自身匹配而不是通配符。或者， ColumnOperators.startswith.escape parameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。

参数

other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志 ColumnOperators.startswith.autoescape 设置为 True，否则不会对 LIKE 通配符 % 和 _ 进行转义。
自动转义¶ –

布尔;当 True 时，建立转义字符，然后将其应用于 “%”、“_” 和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。

表达式，例如：
```
somecolumn.startswith("foo%bar", autoescape=True)
```
将渲染为：
```
somecolumn LIKE :param || '%' ESCAPE '/'
```
:p aram 的值为 “foo/%bar”。
转义¶ –

一个字符，当给定时，它将使用 ESCAPE 关键字将该字符建立为转义字符。然后，可以将此字符放在 % 和 _ 的出现之前，以允许它们充当自身，而不是通配符。

表达式，例如：
```
somecolumn.startswith("foo/%bar", escape="^")
```
将渲染为：
```
somecolumn LIKE :param || '%' ESCAPE '^'
```
该参数也可以与 ColumnOperators.startswith.autoescape ：
```
somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True)
```
在上面，给定的 literal 参数将被转换为 “foo^%bar^^bat” 在传递到数据库之前。

另请参阅

FunctionElement.filter（）

属性 sqlalchemy.sql.expression.ColumnOperators. timetuple： Literal[None] = None¶: Hack 允许在 LHS 上比较日期时间对象。

类 sqlalchemy.sql.expression 中。提取¶: 表示 SQL EXTRACT 子句 extract（field FROM expr）。

类签名

类 sqlalchemy.sql.expression.Extract （ sqlalchemy.sql.expression.ColumnElement ）

类 sqlalchemy.sql.expression 中。False_¶

在 SQL 语句中表示 false 关键字或等效关键字。

False_ 作为常量通过 false（） 函数。

类签名

类 sqlalchemy.sql.expression.False_ （ sqlalchemy.sql.expression.SingletonConstant ， sqlalchemy.sql.roles.ConstExprRole ， sqlalchemy.sql.expression.ColumnElement ）

类 sqlalchemy.sql.expression 中。FunctionFilter（函数过滤器）¶

表示函数 FILTER 子句。

这是针对 aggregate 和 window 函数的特殊运算符，它控制传递给它的行。它仅受某些数据库后端支持。

FunctionFilter 的调用是通过 FunctionElement.filter（） 中：

func.count(1).filter(True)

另请参阅

成员

filter（）、over（）、self_group （）、within_group（）

类签名

类 sqlalchemy.sql.expression.FunctionFilter （ sqlalchemy.sql.expression.Generative ， sqlalchemy.sql.expression.ColumnElement ）

method sqlalchemy.sql.expression.FunctionFilter. filter（*criterion： _ColumnExpressionArgument[bool]）→ Self¶

针对函数生成额外的 FILTER。

此方法将其他条件添加到 FunctionElement.filter（） 设置的初始条件中。

在 SQL 渲染时通过 AND 将多个条件连接在一起。

method sqlalchemy.sql.expression.FunctionFilter. over（partition_by：Iterable[_ColumnExpressionArgument[Any]]_ColumnExpressionArgument[Any]None=None， order_by：Iterable[_ColumnExpressionArgument[Any]]_ColumnExpressionArgument[Any]None=None， range_：typing_Tuple[intNone，intNone]None=None， rows：typing_Tuple[intNone，intNone]None=None）→ over[_T]¶

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

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

表达式：

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（） 。

方法 sqlalchemy.sql.expression.FunctionFilter. self_group（against：OperatorTypeNone=None）→SelfGrouping[_T]¶

将 'grouping' 应用于此 ClauseElement。

此方法被 subclasses 覆盖以返回 “grouping” 结构，即括号。特别是，当它被 “binary” 表达式用于在放入更大的表达式时提供围绕自身的分组，以及 select（） 构造 select（） 的（请注意，子查询通常应使用 Select.alias（） 方法创建，因为许多平台需要命名嵌套的 SELECT 语句）。

由于表达式是组合在一起的，因此 self_group（） 是自动的 - 最终用户代码永远不需要直接使用此方法。请注意，SQLAlchemy 的子句构造考虑了运算符优先级 - 因此可能不需要括号，例如，在像 x OR （y AND z） 这样的表达式中 - AND 优先于 OR。

的 base self_group（） 方法 子句元素 只返回 self。

方法 sqlalchemy.sql.expression.FunctionFilter. within_group（*order_by： _ColumnExpressionArgument[Any]）→ WithinGroup[_T]¶: 针对此函数生成 WITHIN GROUP （ORDER BY expr）子句。

类 sqlalchemy.sql.expression 中。标签¶

表示列标签（AS）。

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

成员

foreign_keys、primary_key、self_group（）

类签名

类 sqlalchemy.sql.expression.Label （ sqlalchemy.sql.roles.LabeledColumnExprRole ， sqlalchemy.sql.expression.NamedColumn ）

属性 sqlalchemy.sql.expression.Label. foreign_keys： AbstractSet[ForeignKey]¶

属性 sqlalchemy.sql.expression.Label. primary_key： bool¶

方法 sqlalchemy.sql.expression.Label. self_group（against：OperatorTypeNone=None）→ Label[_T]¶

将 'grouping' 应用于此 ClauseElement。

此方法被 subclasses 覆盖以返回 “grouping” 结构，即括号。特别是，当它被 “binary” 表达式用于在放入更大的表达式时提供围绕自身的分组，以及 select（） 构造 select（） 的（请注意，子查询通常应使用 Select.alias（） 方法创建，因为许多平台需要命名嵌套的 SELECT 语句）。

由于表达式是组合在一起的，因此 self_group（） 是自动的 - 最终用户代码永远不需要直接使用此方法。请注意，SQLAlchemy 的子句构造考虑了运算符优先级 - 因此可能不需要括号，例如，在像 x OR （y AND z） 这样的表达式中 - AND 优先于 OR。

的 base self_group（） 方法 子句元素 只返回 self。

类 sqlalchemy.sql.expression 中。空值¶

在 SQL 语句中表示 NULL 关键字。

Null 作为常量通过 null（） 函数。

类签名

类 sqlalchemy.sql.expression.Null （ sqlalchemy.sql.expression.SingletonConstant ， sqlalchemy.sql.roles.ConstExprRole ， sqlalchemy.sql.expression.ColumnElement ）

类 sqlalchemy.sql.expression 中。运算符¶

比较基数和逻辑运算符。

实现基方法 Operators.operate（） 和 Operators.reverse_operate（） 以及 Operators.__and__（）、 Operators.__or__（）、 Operators.__invert__（） 中。

成员

__and__（）， __invert__（）， __or__（）， __sa_operate__（）， bool_op（），作（）， reverse_operate （）

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

method sqlalchemy.sql.expression.Operators. __and__（other： Any）→ 运算符¶

实施 & 运算符。

与 SQL 表达式一起使用时，将生成 AND 运算，相当于 and_（）中，即：

a & b

等效于：

from sqlalchemy import and_

and_(a, b)

使用时应小心并考虑运算符的优先顺序;&运算符具有最高的优先级。如果作数包含其他子表达式，则应将其括在括号中：

(a == 2) & (b == 4)

方法 sqlalchemy.sql.expression.Operators. __invert__（）→ 运算符¶

实现 ~ 运算符。

与 SQL 表达式一起使用时，会生成 NOT作，相当于 not_（） 中，即：

~a

等效于：

from sqlalchemy import not_

not_(a)

method sqlalchemy.sql.expression.Operators. __or__（other： Any）→ 运算符¶

实现 | 运算符。

与 SQL 表达式一起使用时，将生成 OR 运算，相当于 or_（）），即：

a | b

等效于：

from sqlalchemy import or_

or_(a, b)

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

(a == 2) | (b == 4)

方法 sqlalchemy.sql.expression.Operators. __sa_operate__（op： OperatorType， *other： Any， **kwargs： Any→ 运营商¶

对参数进行作。

这是最低级别的作，加注 NotImplementedError 的 MethodS 错误。

在子类上覆盖 this 可以允许将通用行为应用于所有作。例如，重写 ColumnOperators 要将 func.lower（） 应用于左侧和右侧：

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

参数

op¶- 运算符可调用。
other¶ ——作的 'other' 端。对于大多数作，将是单个标量。
**kwargs¶ —— 修饰符。这些可以通过特殊运算符（如 ColumnOperators.contains（）））传递。

方法 sqlalchemy.sql.expression.Operators. bool_op（opstring： str， precedence： int = 0， python_impl：Callable[[...]，Any]None=None）→ Callable[[any]，运算符]¶

返回自定义布尔运算符。

此方法是调用 Operators.op（） 并将 Operators.op.is_comparison flag 替换为 True。使用 Operators.bool_op（） 的主要优势是，当使用列构造时，返回的 expression 将用于 PEP 484 目的。

另请参阅

方法 sqlalchemy.sql.expression.Operators. op（opstring： str， precedence： int = 0， is_comparison： bool = false， return_type：Type[TypeEngine[any]]TypeEngine[any]None=None， python_impl：Callable[...，Any]None=None）→ Callable[[any]， operators []¶

生成泛型运算符函数。

例如：

somecolumn.op("*")(5)

生产：

somecolumn * 5

此函数还可用于使按位运算符显式。例如：

somecolumn.op("&")(0xFF)

是 somecolumn 中值的按位 AND。

参数

opstring¶ – 一个字符串，将作为此元素和传递给生成函数的表达式之间的中缀运算符输出。
优先级¶ –

优先级，数据库应应用于 SQL 表达式中的运算符。此整数值充当 SQL 编译器的提示，以了解何时应在特定作周围呈现显式括号。较小的数字将导致表达式在应用于另一个优先级较高的运算符时被括起来。默认值 0 低于除逗号（，）和 AS 运算符之外的所有运算符。值 100 将高于或等于所有运算符，而 -100 将小于或等于所有运算符。

另请参阅

我正在使用 op（）生成自定义运算符，但我的括号没有正确显示 - SQLAlchemy SQL 编译器如何呈现括号的详细说明
is_comparison¶ –

遗产;如果为 True，则该运算符将被视为 “比较” 运算符，即计算结果为布尔值 true/false 值，如 ==、> 等。提供此标志是为了让 ORM 关系可以确定该运算符在自定义连接条件中使用时是比较运算符。

使用 is_comparison 参数将被使用 Operators.bool_op（） 方法;这个更简洁的运算符会自动设置此参数，但也提供正确的 PEP 484 类型支持，因为返回的对象将表示“布尔”数据类型，即 BinaryExpression[bool]。
return_type¶—— TypeEngine 类或对象，它将 force 此运算符生成的表达式的返回类型属于该类型。默认情况下，指定 Operators.op.is_comparison将解析为 Boolean 的 Boolean 和那些不 boolean 的 Boolean 将与左侧作数的类型相同。
python_impl¶ –

一个可选的 Python 函数，该函数可以计算两个 Python 值，其工作方式与此运算符在数据库服务器上运行时的工作方式相同。对于 Python 内部 SQL 表达式评估函数（例如 ORM 混合属性）以及用于在多行更新或删除后匹配会话中的对象的 ORM“评估器”非常有用。

例如：
```
>>> expr = column("x").op("+", python_impl=lambda a, b: a + b)("y")
```
上述表达式的运算符也适用于非 SQL 的 left 和 right 对象：
```
>>> expr.operator(5, 10)
15
```
2.0 版的新Function。

另请参阅

bindParams（）、columns（）、self_group（）

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

method sqlalchemy.sql.expression.Operators. operate（op： OperatorType， *other： Any， **kwargs： Any→ 运营商¶

对参数进行作。

这是最低级别的作，加注 NotImplementedError 的 MethodS 错误。

在子类上覆盖 this 可以允许将通用行为应用于所有作。例如，重写 ColumnOperators 要将 func.lower（） 应用于左侧和右侧：

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

参数

op¶- 运算符可调用。
other¶ ——作的 'other' 端。对于大多数作，将是单个标量。
**kwargs¶ —— 修饰符。这些可以通过特殊运算符（如 ColumnOperators.contains（）））传递。

方法 sqlalchemy.sql.expression.Operators. reverse_operate（op： OperatorType， other： Any， **kwargs： Any）→ 运算符¶

Reverse 对参数进行作。

用法与 operate（） 相同。

类 sqlalchemy.sql.expression 中。结束¶

表示 OVER 子句。

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

成员

元素

类签名

类 sqlalchemy.sql.expression.Over （ sqlalchemy.sql.expression.ColumnElement ）

attribute sqlalchemy.sql.expression.Over. 元素： ColumnElement[_T]¶: 此 Over object 引用。

类 sqlalchemy.sql.expression 中。SQLColumn表达式¶

一种类型，可用于指示任何 SQL 列元素或对象，以代替一个元素或对象。

SQLColumnExpression 是 ColumnElement 以及 ORM 元素（如 InstrumentedAttribute）的基类中，并且可以在 PEP 484 中使用键入以指示应行为的参数或返回值作为列表达式。

2.0.0b4 版本的新Function。

类签名

类 sqlalchemy.sql.expression.SQLColumnExpression （ sqlalchemy.sql.expression.SQLCoreOperations ， sqlalchemy.sql.roles.ExpressionElementRole ， sqlalchemy.util.langhelpers.TypingOnly ）

类 sqlalchemy.sql.expression 中。TextClause 文本子句¶

表示文本 SQL 文本片段。

例如：

from sqlalchemy import text

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

TextClause 构造是使用 文本（） 功能;有关完整文档，请参阅该函数。

另请参阅

文本（）

成员

类签名

类 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.InElementRole sqlalchemy.sql.expression.Generative sqlalchemy.sql.expression.Executable sqlalchemy.sql.expression.DQLDMLClauseElement sqlalchemy.sql.roles.BinaryElementRole sqlalchemy.inspection.Inspectable ）

方法 sqlalchemy.sql.expression.TextClause. bindparams（*binds： BindParameter[Any]， **names_to_values： Any）→ Self¶

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

给定一个文本结构，例如：

from sqlalchemy import text

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

TextClause.bindparams（） method 可用于建立 ：name 和 ：timestamp 的初始值，使用简单的关键字参数：

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

在上面，将生成名称分别为 name 和 timestamp 以及 jack 和 datetime.datetime(2012, 10, 8, 15, 12, 5) 值的新 BindParameter 对象。类型将从给定的值中推断出来，在本例中为 String 和 DateTime 的 Package。

当需要特定的类型行为时，位置 *binds 参数可以直接指定 bindParam（） 结构。这些构造必须至少包含密钥 argument，然后是一个可选值和 type：

from sqlalchemy import bindparam

stmt = stmt.bindparams(
    bindparam("name", value="jack", type_=String),
    bindparam("timestamp", type_=DateTime),
)

在上面，我们为 timestamp 绑定，以及名称的 String 类型捆。对于 name ，我们还将默认值 “杰克”。

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

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

TextClause.bindparams（） method 可以重复调用，它将重用现有的 BindParameter 对象来添加新信息。例如，我们可以调用 TextClause.bindparams（） first 包含键入信息，以及 second time with value information 的，它将被合并：

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（） method 还支持 unique bound 参数。这些参数是在语句编译时对 name 进行 “uniquified”，因此多个 文本（） 构造可以组合在一起，但不需要名称冲突。要使用此功能，请指定 BindParameter.unique 标志对象：

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 标志 文本（） 构建。

method sqlalchemy.sql.expression.TextClause. columns（*cols： _ColumnExpressionArgument[Any]， **types： _TypeEngineArgument[Any]）→ TextualSelect¶

将此 TextClause 对象转换为 文本选择 与 SELECT 具有相同角色的对象陈述。

TextualSelect 是 选择基地 层次结构，并且可以使用 TextualSelect.subquery（） 方法生成 子查询 object，然后可以从中 SELECT 它。

此函数实质上弥合了完全文本的 SELECT 语句与 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（） 方法。这些 列（） 元素现在成为 TextualSelect.selected_columns column 集合，该集合在 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))
)

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 对象，通常 Table 中的列对象或 ORM 级别 column-mapped 属性，表示此 text 字符串将 SELECT from。
types¶– 字符串名称到 TypeEngine 的映射 type 对象，指示要用于 SELECTed 从文本字符串中。更喜欢使用 *cols 参数，因为它还指示位置排序。

方法 sqlalchemy.sql.expression.TextClause. self_group（against：OperatorTypeNone=None）→SelfGrouping[Any]¶

将 'grouping' 应用于此 ClauseElement。

此方法被 subclasses 覆盖以返回 “grouping” 结构，即括号。特别是，当它被 “binary” 表达式用于在放入更大的表达式时提供围绕自身的分组，以及 select（） 构造 select（） 的（请注意，子查询通常应使用 Select.alias（） 方法创建，因为许多平台需要命名嵌套的 SELECT 语句）。

由于表达式是组合在一起的，因此 self_group（） 是自动的 - 最终用户代码永远不需要直接使用此方法。请注意，SQLAlchemy 的子句构造考虑了运算符优先级 - 因此可能不需要括号，例如，在像 x OR （y AND z） 这样的表达式中 - AND 优先于 OR。

的 base self_group（） 方法 子句元素 只返回 self。

类 sqlalchemy.sql.expression 中。TryCast¶

表示 TRY_CAST 表达式。

有关 TryCast 用法的详细信息，请参阅 try_cast（）。

另请参阅

try_cast（）

成员

inherit_cache

类签名

类 sqlalchemy.sql.expression.TryCast （ sqlalchemy.sql.expression.Cast ）

属性 sqlalchemy.sql.expression.TryCast. inherit_cache：boolNone = True¶

指示此 HasCacheKey 实例是否应使用其直接超类使用的缓存键生成方案。

该属性默认为 None，这表示构造尚未考虑是否适合参与缓存;这在功能上等效于将值设置为 False，但还会发出警告。

如果与对象对应的 SQL 不基于此类的本地属性而不是其超类而更改，则可以在特定类上将此标志设置为 True。

另请参阅

启用对自定义构造的缓存支持 - 设置 HasCacheKey.inherit_cache 第三方或用户定义的 SQL 构造的属性。

类 sqlalchemy.sql.expression 中。元组¶

表示 SQL 元组。

成员

类签名

类 sqlalchemy.sql.expression.Tuple （ sqlalchemy.sql.expression.ClauseList ， sqlalchemy.sql.expression.ColumnElement ）

方法 sqlalchemy.sql.expression.Tuple. self_group（against：OperatorTypeNone=None）→ Self¶

将 'grouping' 应用于此 ClauseElement。

此方法被 subclasses 覆盖以返回 “grouping” 结构，即括号。特别是，当它被 “binary” 表达式用于在放入更大的表达式时提供围绕自身的分组，以及 select（） 构造 select（） 的（请注意，子查询通常应使用 Select.alias（） 方法创建，因为许多平台需要命名嵌套的 SELECT 语句）。

由于表达式是组合在一起的，因此 self_group（） 是自动的 - 最终用户代码永远不需要直接使用此方法。请注意，SQLAlchemy 的子句构造考虑了运算符优先级 - 因此可能不需要括号，例如，在像 x OR （y AND z） 这样的表达式中 - AND 优先于 OR。

的 base self_group（） 方法 子句元素 只返回 self。

类 sqlalchemy.sql.expression 中。内部组¶

表示 WITHIN GROUP （ORDER BY）子句。

这是针对所谓的“有序集聚合”和“假设集聚合”函数的特殊运算符，包括 percentile_cont（）、 rank（）、dense_rank（） 等。

它仅受某些数据库后端支持，例如 PostgreSQL、Oracle Database 和 MS SQL Server。

WithinGroup 构造从方法 FunctionElement.within_group_type() . 如果返回 None，则使用函数的 .type。

成员

filter（）、over（）

类签名

类 sqlalchemy.sql.expression.WithinGroup （ sqlalchemy.sql.expression.ColumnElement ）

method sqlalchemy.sql.expression.WithinGroup. filter（*criterion： _ColumnExpressionArgument[bool]）→SelfFunctionFilter[_T]¶: 针对此函数生成 FILTER 子句。

method sqlalchemy.sql.expression.WithinGroup. over（*， partition_by：_ByArgumentNone=None， order_by：_ByArgumentNone=None， rows：typing_Tuple[intNone，intNone]None=None， range_：typing_Tuple[intNone，intNone]None=None）→ over[_T]¶

针对此 WithinGroup 生成 OVER 子句构建。

此函数与 FunctionElement.over（）的 FunctionElement.over（） 中。

类 sqlalchemy.sql.elements 中。WrapsColumnExpression¶: 定义 ColumnElement 的 Mixin 作为带有特殊已具有 name 的表达式的标签行为。

在 1.4 版本加入.

另请参阅

改进了使用 CAST 或类似方法的简单列表达式的列标记

类签名

类 sqlalchemy.sql.expression.WrapsColumnExpression （ sqlalchemy.sql.expression.ColumnElement ）

类 sqlalchemy.sql.expression 中。True_¶

在 SQL 语句中表示 true 关键字或等效关键字。

True_ 作为常量通过 true（） 函数。

类签名

类 sqlalchemy.sql.expression.True_ （ sqlalchemy.sql.expression.SingletonConstant ， sqlalchemy.sql.roles.ConstExprRole ， sqlalchemy.sql.expression.ColumnElement ）

类 sqlalchemy.sql.expression 中。TypeCoerce¶

表示 Python 端类型强制包装器。

TypeCoerce 提供 type_coerce（） 功能;有关使用详情，请参阅该函数。

另请参阅

type_coerce（）

成员

类签名

类 sqlalchemy.sql.expression.TypeCoerce （ sqlalchemy.sql.expression.WrapsColumnExpression ）

方法 sqlalchemy.sql.expression.TypeCoerce. self_group（against：OperatorTypeNone=None）→ TypeCoerce[_T]¶

将 'grouping' 应用于此 ClauseElement。

此方法被 subclasses 覆盖以返回 “grouping” 结构，即括号。特别是，当它被 “binary” 表达式用于在放入更大的表达式时提供围绕自身的分组，以及 select（） 构造 select（） 的（请注意，子查询通常应使用 Select.alias（） 方法创建，因为许多平台需要命名嵌套的 SELECT 语句）。

由于表达式是组合在一起的，因此 self_group（） 是自动的 - 最终用户代码永远不需要直接使用此方法。请注意，SQLAlchemy 的子句构造考虑了运算符优先级 - 因此可能不需要括号，例如，在像 x OR （y AND z） 这样的表达式中 - AND 优先于 OR。

的 base self_group（） 方法 子句元素 只返回 self。

类 sqlalchemy.sql.expression 中。一元表达式¶

定义 'unary' 表达式。

一元表达式具有单个列表达式和一个运算符。运算符可以放置在列表达式的左侧（称为 'operator'）或右侧（称为 'modifier'）。

一元表达式是几个一元运算符的基础，包括 desc（）、asc（）、distinct（） 使用的运算符、 nulls_first（） 和 nulls_last（） 来获取。

成员