SqlAlchemy 2.0 中文文档（二十九）（5）

SqlAlchemy 2.0 中文文档（二十九）（4）https://developer.aliyun.com/article/1560467

参数：

other – 一组文字，一个select() 构造，或者一个包括``bindparam()构造，该构造包含设置为True的bindparam.expanding`标志。

method is_(other: Any) → ColumnOperators

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

实现IS运算符。

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

另请参见

ColumnOperators.is_not()

method is_distinct_from(other: Any) → ColumnOperators

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

实现IS DISTINCT FROM运算符。

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

method is_not(other: Any) → ColumnOperators

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

实现IS NOT运算符。

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

从版本 1.4 开始更改：is_not()运算符从先前的版本中的isnot()重命名。以前的名称保留以确保向后兼容性。

另请参见

ColumnOperators.is_()

method is_not_distinct_from(other: Any) → ColumnOperators

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

实现 IS NOT DISTINCT FROM 运算符。

在大多数平台上渲染为“a IS NOT DISTINCT FROM b”；在某些平台上（如 SQLite），可能渲染为“a IS b”。

在版本 1.4 中进行了更改：is_not_distinct_from() 运算符从先前版本的 isnot_distinct_from() 更名。先前的名称仍然可用于向后兼容。

method isnot(other: Any) → ColumnOperators

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

实现 IS NOT 运算符。

通常，当与None的值比较时，将自动生成IS NOT，其解析为NULL。然而，在某些平台上，如果与布尔值进行比较，则可能需要显式使用IS NOT。

在版本 1.4 中进行了更改：is_not() 运算符从先前版本的 isnot() 更名。先前的名称仍然可用于向后兼容。

另请参见

ColumnOperators.is_()

method isnot_distinct_from(other: Any) → ColumnOperators

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

实现 IS NOT DISTINCT FROM 运算符。

在大多数平台上渲染为“a IS NOT DISTINCT FROM b”；在某些平台上（如 SQLite），可能渲染为“a IS b”。

在版本 1.4 中进行了更改：is_not_distinct_from() 运算符从先前版本的 isnot_distinct_from() 更名。先前的名称仍然可用于向后兼容。

method istartswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

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

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

生成一个 LIKE 表达式，用于对字符串值的起始部分进行不区分大小写的匹配：

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

例如：

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

由于该运算符使用 LIKE，因此存在于表达式中的通配符字符 "%" 和 "_" 也将像通配符一样起作用。对于字面字符串值，可以将ColumnOperators.istartswith.autoescape标志设置为True，以对字符串值内这些字符的出现进行转义，使它们匹配为自身而不是通配符字符。或者，ColumnOperators.istartswith.escape参数将建立一个给定字符作为转义字符，当目标表达式不是字面字符串时可能会有用。

参数：

• other – 要比较的表达式。通常是一个普通的字符串值，但也可以是任意的 SQL 表达式。除非将ColumnOperators.istartswith.autoescape标志设置为 True，否则不会默认转义 LIKE 通配符字符 % 和 _。
  
• autoescape –
  布尔值；当为 True 时，在 LIKE 表达式中建立一个转义字符，然后将其应用于比较值中所有出现的"%"、"_"和转义字符本身，假定比较值是一个字面字符串而不是 SQL 表达式。
  例如：

somecolumn.istartswith("foo%bar", autoescape=True)

• 将呈现为：

lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'

• 其值为 :param 的 "foo/%bar"。
• escape –
  一个给定的字符，当给定时将使用 ESCAPE 关键字来建立该字符作为转义字符。然后可以将此字符放在 % 和 _ 的前面，以允许它们作为自身而不是通配符字符。
  例如：

somecolumn.istartswith("foo/%bar", escape="^")

• 将呈现为：

lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'

• 参数也可以与ColumnOperators.istartswith.autoescape结合使用：

somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)

• 在上述情况下，给定的字面参数将在传递到数据库之前转换为"foo^%bar^^bat"。

另请参见

ColumnOperators.startswith()

method like(other: Any, escape: str | None = None) → ColumnOperators

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

实现 like 运算符。

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

a LIKE other

例如：

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

参数：

• other – 要比较的表达式
  
• escape –
  可选的转义字符，渲染ESCAPE关键字，例如：

somecolumn.like("foo/%bar", escape="/")

另请参阅

ColumnOperators.ilike()

attribute local_attr

继承自 AssociationProxyInstance.local_attr 属性的 AssociationProxyInstance

此处引用的‘local’类属性由AssociationProxyInstance引用。

另请参阅

AssociationProxyInstance.attr

AssociationProxyInstance.remote_attr

method match(other: Any, **kwargs: Any) → ColumnOperators

继承自 ColumnOperators.match() 方法的 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 兼容。
  

method not_ilike(other: Any, escape: str | None = None) → ColumnOperators

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

实现NOT ILIKE运算符。

这等同于使用对 ColumnOperators.ilike() 的否定，即 ~x.ilike(y)。

在 1.4 版本中更改：not_ilike()运算符从之前的版本中的notilike()重命名。以前的名称仍可用于向后兼容。

参见

ColumnOperators.ilike()

method not_in(other: Any) → ColumnOperators

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

实现NOT IN运算符。

这等同于使用对 ColumnOperators.in_() 的否定，即 ~x.in_(y)。

在other是空序列的情况下，编译器产生一个“空的不在”表达式。这默认为表达式“1 = 1”，以在所有情况下产生真值。 create_engine.empty_in_strategy 可用于更改此行为。

在 1.4 版本中更改：not_in()运算符从之前的版本中的notin_()重命名。以前的名称仍可用于向后兼容。

在 1.2 版本中更改：ColumnOperators.in_() 和 ColumnOperators.not_in() 运算符现在默认为一个空的 IN 序列生成一个“静态”表达式。

参见

ColumnOperators.in_()

method not_like(other: Any, escape: str | None = None) → ColumnOperators

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

实现NOT LIKE运算符。

这等同于使用对 ColumnOperators.like() 的否定，即 ~x.like(y)。

在 1.4 版本中更改：not_like()运算符从之前的版本中的notlike()重命名。以前的名称仍可用于向后兼容。

参见

ColumnOperators.like()。

method notilike(other: Any, escape: str | None = None) → ColumnOperators

继承自 ColumnOperators.notilike() 的方法 ColumnOperators。

实现NOT ILIKE操作符。

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

从版本 1.4 开始更改：not_ilike()操作符从之前的版本中的notilike()重命名。以前的名称仍然可用以保持向后兼容性。

另请参阅。

ColumnOperators.ilike()。

method notin_(other: Any) → ColumnOperators

继承自 ColumnOperators.notin_() 的方法 ColumnOperators。

实现NOT IN操作符。

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

如果other是一个空序列，编译器将产生一个“空不在”表达式。默认情况下，这会变成表达式“1 = 1”，以在所有情况下产生 true。create_engine.empty_in_strategy可以用来改变这种行为。

从版本 1.4 开始更改：not_in()操作符从之前的版本中的notin_()重命名。以前的名称仍然可用以保持向后兼容性。

从版本 1.2 开始更改：ColumnOperators.in_()和ColumnOperators.not_in()操作符现在默认情况下为一个空的 IN 序列产生一个“静态”表达式。

另请参阅。

ColumnOperators.in_()。

method notlike(other: Any, escape: str | None = None) → ColumnOperators

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

实现NOT LIKE运算符。

这等同于使用ColumnOperators.like()的否定，即~x.like(y)。

从版本 1.4 开始更改：not_like()运算符从先前版本的notlike()重命名。以确保向后兼容性，先前的名称仍然可用。

另请参阅

ColumnOperators.like()

method nulls_first() → ColumnOperators

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

生成针对父对象的nulls_first()子句。

从版本 1.4 开始更改：nulls_first()运算符从先前版本的nullsfirst()重命名。以确保向后兼容性，先前的名称仍然可用。

method nulls_last() → ColumnOperators

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

生成针对父对象的nulls_last()子句。

从版本 1.4 开始更改：nulls_last()运算符从先前版本的nullslast()重命名。以确保向后兼容性，先前的名称仍然可用。

method nullsfirst() → ColumnOperators

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

生成针对父对象的nulls_first()子句。

从版本 1.4 开始更改：nulls_first()运算符从先前版本的nullsfirst()重命名。以确保向后兼容性，先前的名称仍然可用。

method nullslast() → ColumnOperators

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

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

1.4 版更改：在以前的版本中，nulls_last()操作符从nullslast()重命名。以前的名称仍可用于向后兼容。

method 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.op() 方法的 Operators

生成一个通用的运算符函数。

例如：

somecolumn.op("*")(5)

产生：

somecolumn * 5

此函数还可用于明确表示按位运算符。例如：

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

是somecolumn中的值的按位与。

参数：

• opstring – 将作为此元素与传递给生成函数的表达式之间的中缀运算符输出的字符串。
  
• precedence –
  数据库预计将在 SQL 表达式中应用到运算符的优先级。这个整数值作为 SQL 编译器的提示，用于知道何时应该在特定操作周围渲染显式括号。较低的数字将导致在应用到具有较高优先级的另一个运算符时表达式被括起来。默认值为0，低于所有运算符，除了逗号（,）和AS运算符。值为 100 将高于或等于所有运算符，而-100 将低于或等于所有运算符。
  另请参阅
  我正在使用 op()生成自定义运算符，但我的括号显示不正确 - SQLAlchemy SQL 编译器如何渲染括号的详细描述
  
• is_comparison –
  遗留；如果为 True，则运算符将被视为“比较”运算符，即评估为布尔值的运算符，如==，>等。提供此标志是为了 ORM 关系能够在自定义连接条件中使用运算符时建立该运算符是比较运算符的关系。
  使用is_comparison参数已被使用Operators.bool_op() 方法取代；这更简洁的操作符会自动设置此参数，但也提供了正确的PEP 484 类型支持，因为返回的对象将表示“布尔”数据类型，即 BinaryExpression[bool]。
  
• return_type – TypeEngine 类或对象，将强制此操作符产生的表达式的返回类型为该类型。默认情况下，指定了 Operators.op.is_comparison 的操作符将解析为 Boolean，而那些没有的操作符将与左操作数相同类型。
  
• python_impl –
  一个可选的  Python 函数，可以以与数据库服务器上运行此操作符时相同的方式评估两个 Python 值。对于在 Python 中的 SQL  表达式评估函数（例如用于 ORM 混合属性的函数）以及用于在多行更新或删除后匹配会话中的对象的 ORM “评估器”非常有用。
  例如：

>>> expr = column('x').op('+', python_impl=lambda a, b: a + b)('y')

• 上述表达式的操作符也适用于非 SQL 左右对象：

>>> expr.operator(5, 10)
15

• 新版本 2.0 中。

另请参阅

Operators.bool_op()

重新定义和创建新操作符

在连接条件中使用自定义操作符

method operate(op: OperatorType, *other: Any, **kwargs: Any) → Operators

继承自 Operators.operate() 方法的 Operators

对参数进行操作。

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

在子类上重写此方法可以使通用行为应用于所有操作。例如，重写 ColumnOperators 以对左侧和右侧应用 func.lower()：

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

参数：

• op – 操作符可调用对象。
  
• *other – 操作的‘另一’方。对于大多数操作来说，将是一个单一的标量。
  
• **kwargs – 修饰符。这些可以通过特殊操作符传递，比如 ColumnOperators.contains()。
  

method regexp_match(pattern: Any, flags: str | None = None) → ColumnOperators

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

实现了数据库特定的‘正则匹配’操作符。

例如：

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

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

示例包括：

• PostgreSQL - 在否定时呈现 x ~ y 或 x !~ y。
  
• Oracle - 呈现 REGEXP_LIKE(x, y)
  
• SQLite - 使用 SQLite 的 REGEXP 占位符操作符，并调用 Python 的 re.match() 内建函数。
  
• 其他后端可能提供特殊的实现。
  
• 没有任何特殊实现的后端将发出操作符为 “REGEXP” 或 “NOT REGEXP”。例如，这与 SQLite 和 MySQL 兼容。
  

目前正则表达式支持已经在 Oracle、PostgreSQL、MySQL 和 MariaDB 中实现。SQLite 可用部分支持。第三方方言中的支持可能有所不同。

参数：

• pattern – 正则表达式模式字符串或列子句。
  
• flags – 任何要应用的正则表达式字符串标志，仅作为普通 Python 字符串传递。这些标志是特定于后端的。某些后端，如 PostgreSQL 和  MariaDB，可能会将标志作为模式的一部分来指定。在 PostgreSQL 中使用忽略大小写标志 ‘i’  时，将使用忽略大小写的正则表达式匹配操作符 ~* 或 !~*。
  

从版本 1.4 开始。

从版本 1.4.48 改变为：2.0.18 请注意，由于实现错误，以前的“flags”参数除了纯 Python 字符串外，还接受 SQL  表达式对象（例如列表达式）。该实现在缓存方面不能正常工作，已被移除；应该只传递字符串作为“flags”参数，因为这些标志会被渲染为 SQL  表达式中的文字内联值。

另请参阅

ColumnOperators.regexp_replace()

method regexp_replace(pattern: Any, replacement: Any, flags: str | None = None) → ColumnOperators

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

实现了数据库特定的“正则表达式替换”操作符。

例如：

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

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

目前为止，正则表达式替换支持已经在 Oracle、PostgreSQL、MySQL 8 或更高版本和 MariaDB 中实现。第三方方言中的支持可能有所不同。

参数：

• pattern – 正则表达式模式字符串或列子句。
  
• pattern – 替换字符串或列子句。
  
• flags – 要应用的任何正则表达式字符串标志，仅作为普通 Python 字符串传递。这些标志是后端特定的。某些后端，如 PostgreSQL 和 MariaDB，可能会将标志作为模式的一部分来指定。
  

版本 1.4 中的新功能。

从版本 1.4.48 开始更改，: 2.0.18 请注意，由于实现错误，“flags”参数先前接受了 SQL  表达式对象，如列表达式，除了普通的 Python 字符串。此实现与缓存不正确，已删除；仅应传递字符串以用于“flags”参数，因为这些标志将作为  SQL 表达式中的文字内联值呈现。

另请参阅

ColumnOperators.regexp_match()。

attribute remote_attr

继承自 AssociationProxyInstance.remote_attr 属性的 AssociationProxyInstance。

此 AssociationProxyInstance 引用的“remote”类属性。

另请参阅

AssociationProxyInstance.attr。

AssociationProxyInstance.local_attr。

method reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → Operators

继承自 Operators.reverse_operate() 方法的 Operators。

对参数进行反向操作。

用法与 operate() 相同。

attribute scalar

继承自 AssociationProxyInstance.scalar 属性的 AssociationProxyInstance。

如果此 AssociationProxyInstance 代理本地端的标量关系，则返回True。

method startswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

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

实现 startswith 运算符。

生成一个 LIKE 表达式，用于测试字符串值的开头匹配：

column LIKE <other> || '%'

例如：

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

由于该运算符使用 LIKE，因此存在于 表达式中的通配符字符 "%" 和 "_" 也将像通配符一样起作用。对于字面字符串值，可以将 ColumnOperators.startswith.autoescape 标志设置为 True，以对字符串值中这些字符的出现进行转义，使它们与自身匹配而不是作为通配符字符。或者，ColumnOperators.startswith.escape 参数将建立一个给定的字符作为转义字符，当目标表达式不是字面字符串时，这可能会有用。

参数：

• other – 要比较的表达式。通常是一个普通字符串值，但也可以是任意的 SQL 表达式。除非将 ColumnOperators.startswith.autoescape 标志设置为 True，否则 LIKE 通配符 % 和 _ 默认不会被转义。
  
• autoescape –
  布尔值；当为 True 时，在 LIKE 表达式中建立一个转义字符，然后将其应用于比较值中所有出现的 "%"、"_" 和转义字符本身，假定比较值是一个字面字符串而不是 SQL 表达式。
  诸如以下表达式：

somecolumn.startswith("foo%bar", autoescape=True)

• 将呈现为：

somecolumn LIKE :param || '%' ESCAPE '/'

• 其值为 :param，为 "foo/%bar"。
• escape –
  一个字符，当给定时，将使用 ESCAPE 关键字来建立该字符作为转义字符。然后可以将该字符放在 % 和 _ 的前面，以使它们作为自身而不是通配符字符。
  诸如以下表达式：

somecolumn.startswith("foo/%bar", escape="^")

• 将呈现为：

somecolumn LIKE :param || '%' ESCAPE '^'

• 该参数也可以与 ColumnOperators.startswith.autoescape 结合使用：

somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True)

• 在上述情况下，给定的字面参数将在传递到数据库之前转换为 "foo^%bar^^bat"。

另请参阅

ColumnOperators.endswith()

ColumnOperators.contains()

ColumnOperators.like()

attribute target_class: Type[Any]

此 AssociationProxyInstance 处理的中间类。

拦截的追加/设置/赋值事件将导致生成此类的新实例。

attribute timetuple: Literal[None] = None

继承自 ColumnOperators 的 ColumnOperators.timetuple *属性。

允许将 datetime 对象放在左侧进行比较的 Hack。

class sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance

一个以数据库列为目标的 AssociationProxyInstance。

成员

le(), lt(), ne(),  all_(), any(), any_(), asc(), attr, between(), bitwise_and(),  bitwise_lshift(), bitwise_not(), bitwise_or(), bitwise_rshift(),  bitwise_xor(), bool_op(), collate(), concat(), contains(), desc(),  distinct(), endswith(), has(), icontains(), iendswith(), ilike(), in_(),  is_(), is_distinct_from(), is_not(), is_not_distinct_from(), isnot(),  isnot_distinct_from(), istartswith(), like(), local_attr, match(),  not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(),  nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(),  regexp_match(), regexp_replace(), remote_attr, reverse_operate(),  scalar, startswith(), target_class, timetuple

类签名

类 sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance (sqlalchemy.ext.associationproxy.AssociationProxyInstance)

method __le__(other: Any) → ColumnOperators

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

实现 <= 运算符。

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

method __lt__(other: Any) → ColumnOperators

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

实现 < 运算符。

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

method __ne__(other: Any) → ColumnOperators

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

实现 != 运算符。

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

method all_() → ColumnOperators

继承自 ColumnOperators 的 ColumnOperators.all_() *方法。

对父对象生成一个all_()子句。

查看 all_() 的文档以获取示例。

注意

请确保不要混淆较新的 ColumnOperators 的 ColumnOperators.all_() *方法与传统版本的此方法，即 Comparator.all() 方法，该方法专门针对 ARRAY，使用不同的调用风格。

method any(criterion: _ColumnExpressionArgument[bool] | None = None, **kwargs: Any) → ColumnElement[bool]

继承自 AssociationProxyInstance 的 AssociationProxyInstance.any() *方法。

使用 EXISTS 生成一个代理的 ‘any’ 表达式。

此表达式将使用基础代理属性的Comparator.any()和/或Comparator.has()运算符组合成一个产品。

method any_() → ColumnOperators

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

生成针对父对象的any_()子句。

有关示例，请参阅any_()的文档。

注意

请确保不要混淆较新的ColumnOperators.any_()方法与此方法的传统版本，即专用于ARRAY的Comparator.any()方法，其使用不同的调用风格。

method asc() → ColumnOperators

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

生成针对父对象的asc()子句。

attribute attr

继承自 AssociationProxyInstance.attr 属性的 AssociationProxyInstance

返回一个元组(local_attr, remote_attr)。

此属性最初旨在简化使用Query.join()方法一次性跨越两个关系，但这使用了一个已弃用的调用风格。

要使用select.join()或Query.join()与关联代理，当前方法是分别使用AssociationProxyInstance.local_attr和AssociationProxyInstance.remote_attr属性：

stmt = (
    select(Parent).
    join(Parent.proxied.local_attr).
    join(Parent.proxied.remote_attr)
)

未来的版本可能会为关联代理属性提供更简洁的连接模式。

请参见

AssociationProxyInstance.local_attr

AssociationProxyInstance.remote_attr

method between(cleft: Any, cright: Any, symmetric: bool = False) → ColumnOperators

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

生成针对父对象的 between() 子句，给定下限和上限范围。

method bitwise_and(other: Any) → ColumnOperators

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

生成按位 AND 操作，通常通过 & 运算符。

2.0.2 版本中的新功能。

请参见

按位运算符

method bitwise_lshift(other: Any) → ColumnOperators

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

生成按位 LSHIFT 操作，通常通过 << 运算符。

2.0.2 版本中的新功能。

请参见

按位运算符

method bitwise_not() → ColumnOperators

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

生成按位 NOT 操作，通常通过 ~ 运算符。

2.0.2 版本中的新功能。

请参见

按位运算符

method bitwise_or(other: Any) → ColumnOperators

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

生成按位 OR 操作，通常通过 | 运算符。

2.0.2 版本中的新功能。

请参见

按位运算符

method bitwise_rshift(other: Any) → ColumnOperators

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

生成位右移操作，通常通过>>运算符。

版本 2.0.2 中的新功能。

另请参阅

位运算符

method bitwise_xor(other: Any) → ColumnOperators

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

生成位异或操作，通常通过^运算符，或者对于 PostgreSQL 使用#。

版本 2.0.2 中的新功能。

另请参阅

位运算符

method bool_op(opstring: str, precedence: int = 0, python_impl: Callable[[...], Any] | None = None) → Callable[[Any], Operators]

继承自 Operators.bool_op() 方法的 Operators

返回自定义布尔运算符。

此方法是调用Operators.op()并传递Operators.op.is_comparison标志为 True 的简写。 使用Operators.bool_op()的一个关键优势是，在使用列构造时，返回表达式的“布尔”性质将出现在PEP 484中。

另请参阅

Operators.op()

method collate(collation: str) → ColumnOperators

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

生成针对父对象的collate()子句，给定排序字符串。

另请参阅

collate()

method concat(other: Any) → ColumnOperators

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

实现‘连接’操作符。

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

method contains(other: Any, **kw: Any) → ColumnOperators

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

实现‘包含’操作符。

产生一个用于测试字符串值中间匹配的 LIKE 表达式：

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

例如：

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

由于操作符使用了 LIKE，所以在 表达式内出现的通配符字符 "%" 和 "_" 也会像通配符一样运行。对于字面字符串值，可以设置 ColumnOperators.contains.autoescape 标志为 True 来对字符串值内出现的这些字符进行转义，使它们与自身匹配而不是作为通配符字符。或者，ColumnOperators.contains.escape 参数将建立一个给定的字符作为转义字符，这在目标表达式不是字面字符串时可能会有用。

参数：

• other – 要进行比较的表达式。这通常是一个普通的字符串值，但也可以是任意的 SQL 表达式。除非设置了 ColumnOperators.contains.autoescape 标志为 True，否则 LIKE 通配符字符 % 和 _ 不会被默认转义。
  
• autoescape –
  布尔值；当为 True 时，在 LIKE 表达式中建立一个转义字符，然后将其应用于比较值中所有出现的"%"、"_"和转义字符本身，假定比较值为字面字符串而不是 SQL 表达式。
  例如这样的表达式：

somecolumn.contains("foo%bar", autoescape=True)

• 将渲染为：

somecolumn LIKE '%' || :param || '%' ESCAPE '/'

• 其中：param的值为"foo/%bar"。
• escape –
  当给定时，将使用 ESCAPE 关键字来确定该字符作为转义字符。然后，该字符可以放在 % 和 _ 的前面以允许它们作为自身而不是通配符字符。
  例如这样的表达式：

somecolumn.contains("foo/%bar", escape="^")

• 将渲染为：

somecolumn LIKE '%' || :param || '%' ESCAPE '^'

• 参数还可以与 ColumnOperators.contains.autoescape 结合使用：

somecolumn.contains("foo%bar^bat", escape="^", autoescape=True)

• 在上述情况下，给定的字面参数在传递到数据库之前将被转换为"foo^%bar^^bat"。

另请参阅

ColumnOperators.startswith()

ColumnOperators.endswith()

ColumnOperators.like()

method desc() → ColumnOperators

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

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

method distinct() → ColumnOperators

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

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

method endswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

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

实现‘endswith’运算符。

生成一个 LIKE 表达式，用于测试字符串值的结尾是否匹配：

column LIKE '%' || <other>

例如：

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

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

参数：

• other – 要比较的表达式。这通常是一个简单的字符串值，但也可以是任意的 SQL 表达式。默认情况下，LIKE 通配符字符%和_不会被转义，除非设置了ColumnOperators.endswith.autoescape标志为 True。
  
• autoescape –
  布尔值；当为 True 时，在 LIKE 表达式中建立一个转义字符，然后将其应用于比较值中所有的"%"、"_"和转义字符本身的出现，假定比较值是一个字面字符串而不是 SQL 表达式。
  一个表达式如下：

somecolumn.endswith("foo%bar", autoescape=True)

• 将呈现为：

somecolumn LIKE '%' || :param ESCAPE '/'

• 使用值:param为"foo/%bar"。
• escape –
  一个字符，当给定时，将使用ESCAPE关键字将该字符建立为转义字符。然后可以将该字符放在%和_的前面，以允许它们作为自身而不是通配符字符。
  一个表达式如下：

somecolumn.endswith("foo/%bar", escape="^")

• 将呈现为：

somecolumn LIKE '%' || :param ESCAPE '^'

• 该参数也可以与ColumnOperators.endswith.autoescape结合使用：

somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)

• 在上述情况下，给定的字面参数将在传递到数据库之前转换为"foo^%bar^^bat"。

另请参见

ColumnOperators.startswith()

ColumnOperators.contains()

ColumnOperators.like()

method has(criterion: _ColumnExpressionArgument[bool] | None = None, **kwargs: Any) → ColumnElement[bool]

继承自 AssociationProxyInstance.has() 方法的 AssociationProxyInstance

生成一个使用 EXISTS 的代理‘has’表达式。

这个表达式将是使用基础代理属性的Comparator.any()和/或Comparator.has()运算符组成的复合产品。

method icontains(other: Any, **kw: Any) → ColumnOperators

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

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

生成一个 LIKE 表达式，测试一个字符串值中间的不区分大小写匹配：

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

例如：

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

由于该运算符使用了LIKE，因此存在于表达式内部的通配符字符"%"和"_"也会像通配符一样起作用。对于字面字符串值，可以将 ColumnOperators.icontains.autoescape 标志设置为True，以对字符串值内这些字符的出现进行转义，使它们与自身匹配而不是作为通配符字符。或者，ColumnOperators.icontains.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是字面字符串时可能会有用。

参数：

• other – 要比较的表达式。这通常是一个普通字符串值，但也可以是一个任意的 SQL 表达式。默认情况下，不会转义 LIKE 通配符字符%和_，除非设置了 ColumnOperators.icontains.autoescape 标志为 True。
  
• autoescape –
  布尔值；当为 True 时，在 LIKE 表达式中建立一个转义字符，然后将其应用于比较值中所有出现的"%"、"_"和转义字符本身，假设比较值是一个字面字符串而不是一个 SQL 表达式。
  例如：

somecolumn.icontains("foo%bar", autoescape=True)

• 渲染为：

lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'

• 其值为 :param，如 "foo/%bar"。
• escape –
  当给定一个字符时，将使用 ESCAPE 关键字将其设置为转义字符。然后可以在 % 和 _ 的前面放置该字符，以允许它们被视为其自身而不是通配符字符。
  例如：

somecolumn.icontains("foo/%bar", escape="^")

• 将呈现为：

lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'

• 该参数还可以与 ColumnOperators.contains.autoescape 结合使用：

somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)

• 在上述情况下，给定的字面参数将在传递到数据库之前被转换为 "foo^%bar^^bat"。

另请参阅：

ColumnOperators.contains()

method iendswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

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

实现 iendswith 操作符，例如对 ColumnOperators.endswith() 的不区分大小写版本。

生成一个 LIKE 表达式，用于对字符串值的结尾进行不区分大小写匹配：

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

例如：

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

由于该操作符使用 LIKE，因此存在于 表达式内部的通配符字符 "%" 和 "_" 也将像通配符一样起作用。对于字面字符串值，可以将 ColumnOperators.iendswith.autoescape 标志设置为 True，以对字符串值内部这些字符的出现进行转义，使它们匹配为其自身而不是通配符字符。或者，ColumnOperators.iendswith.escape 参数将建立一个给定的字符作为转义字符，这在目标表达式不是字面字符串时可能会有用。

参数：

• other – 表示要比较的表达式。通常是一个普通字符串值，但也可以是任意的 SQL 表达式。LIKE 通配符字符 % 和 _ 默认不被转义，除非 ColumnOperators.iendswith.autoescape 标志被设置为 True。
  
• autoescape –
  布尔值；当为 True 时，在 LIKE 表达式中建立转义字符，然后将其应用于比较值内的所有 "%"、"_" 和转义字符本身的出现，假定比较值为字面字符串而不是 SQL 表达式。
  诸如此类的表达式：

somecolumn.iendswith("foo%bar", autoescape=True)

• 将渲染为：

lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'

• 其值为 :param，为 "foo/%bar"。
• escape –
  给定一个字符，它将与 ESCAPE 关键字一起渲染，以将该字符确定为转义字符。然后，可以将该字符放在 % 和 _ 的前面，以使它们充当自己而不是通配符字符。
  诸如此类的表达式：

somecolumn.iendswith("foo/%bar", escape="^")

• 将渲染为：

lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'

• 参数也可以与 ColumnOperators.iendswith.autoescape 结合使用：

somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)

• 在上述情况下，给定的字面参数将在传递到数据库之前转换为 "foo^%bar^^bat"。

另请参见

ColumnOperators.endswith()

method ilike(other: Any, escape: str | None = None) → ColumnOperators

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

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

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

lower(a) LIKE lower(other)

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

a ILIKE other

例如：

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

参数：

• other – 要比较的表达式
  
• escape –
  可选转义字符，渲染 ESCAPE 关键字，例如：

somecolumn.ilike("foo/%bar", escape="/")

另请参见

ColumnOperators.like()

method in_(other: Any) → ColumnOperators

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

实现 in 运算符。

在列上下文中，生成子句 column IN 。

给定参数 other 可能是：

• 一个字面值列表，例如：

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

• 在此调用形式中，将项目列表转换为与给定列表相同长度的绑定参数集：

WHERE COL IN (?, ?, ?)

• 如果比较针对包含多个表达式的 tuple_()，则可以提供元组列表：

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

• 空列表，例如：

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

• 在这种调用形式中，表达式渲染一个“空集”表达式。这些表达式是针对各个后端定制的，通常试图获得一个空的 SELECT 语句作为子查询。例如，在 SQLite 上，表达式是：

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

• 从版本 1.4 开始：所有情况下，空的 IN 表达式现在都使用执行时生成的 SELECT 子查询。
• 如果包含 bindparam.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 开始：添加了“扩展”绑定参数
  如果传递了一个空列表，则渲染一个特殊的“空列表”表达式，该表达式特定于所使用的数据库。在 SQLite 上，这将是：

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

• 从版本 1.3 开始：现在支持空列表的“扩展”绑定参数
• 一个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() 构造的列表，该构造设置了 bindparam.expanding 标志为 True。

method is_(other: Any) → ColumnOperators

从 ColumnOperators.is_() 方法继承

实现 IS 运算符。

通常，当与None的值进行比较时，会自动生成 IS，它解析为NULL。但是，在某些平台上，如果要与布尔值进行比较，则可能希望明确使用 IS。

另请参见

ColumnOperators.is_not()

method is_distinct_from(other: Any) → ColumnOperators

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

实现 IS DISTINCT FROM 操作符。

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

method is_not(other: Any) → ColumnOperators

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

实现 IS NOT 操作符。

通常情况下，与 None 的值比较时会自动生成 IS NOT，该值解析为 NULL。但是，如果在某些平台上比较布尔值，则可能希望明确使用 IS NOT。

在 1.4 版本中更改：is_not() 操作符从以前的版本中的 isnot() 重命名为 is_not()。以前的名称仍可供向后兼容使用。

另请参阅

ColumnOperators.is_()

method is_not_distinct_from(other: Any) → ColumnOperators

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

实现 IS NOT DISTINCT FROM 操作符。

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

在 1.4 版本中更改：is_not_distinct_from() 操作符从以前的版本中的 isnot_distinct_from() 重命名为 is_not_distinct_from()。以前的名称仍可供向后兼容使用。

method isnot(other: Any) → ColumnOperators

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

实现 IS NOT 操作符。

通常情况下，与 None 的值比较时会自动生成 IS NOT，该值解析为 NULL。但是，如果在某些平台上比较布尔值，则可能希望明确使用 IS NOT。

在 1.4 版本中更改：is_not() 操作符从以前的版本中的 isnot() 重命名为 is_not()。以前的名称仍可供向后兼容使用。

另请参阅

ColumnOperators.is_()

method isnot_distinct_from(other: Any) → ColumnOperators

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

实现 IS NOT DISTINCT FROM 运算符。

在大多数平台上呈现“a IS NOT DISTINCT FROM b”；在一些平台上如 SQLite 可能呈现“a IS b”。

在 1.4 版本中更改：is_not_distinct_from() 运算符从之前版本的 isnot_distinct_from() 重命名。以确保向后兼容性，之前的名称仍然可用。

method istartswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

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

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

生成一个对字符串值开头的不区分大小写匹配的 LIKE 表达式：

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

例如：

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

由于该运算符使用 LIKE，因此存在于 表达式中的通配符字符 "%" 和 "_" 也将像通配符一样起作用。对于字面字符串值，可以将 ColumnOperators.istartswith.autoescape 标志设置为 True，以对字符串值中这些字符的出现进行转义，使其作为自身而不是通配符字符进行匹配。或者，ColumnOperators.istartswith.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是字面字符串时可能会有用。

参数：

• other – 要比较的表达式。通常是一个普通字符串值，但也可以是任意 SQL 表达式。除非将 ColumnOperators.istartswith.autoescape 标志设置为 True，否则 LIKE 通配符字符 % 和 _ 不会被转义。
  
• autoescape –
  布尔值；当为 True 时，在 LIKE 表达式中建立一个转义字符，然后将其应用于比较值中所有出现的 "%"、"_" 和转义字符本身，假定比较值是一个字面字符串而不是 SQL 表达式。
  例如表达式：

somecolumn.istartswith("foo%bar", autoescape=True)

• 将呈现为：

lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'

• 其中param的值为"foo/%bar"。
• escape –
  一个字符，当给定时，将呈现为带有ESCAPE关键字的转义字符。然后，可以将此字符放在%和_之前，以使它们作为自身而不是通配符字符。
  例如表达式：

somecolumn.istartswith("foo/%bar", escape="^")

• 将呈现为：

lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'

• 参数也可以与ColumnOperators.istartswith.autoescape结合使用：

somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)

• 在上述情况下，给定的文字参数将在传递到数据库之前转换为"foo^%bar^^bat"。

另请参阅

ColumnOperators.startswith()

method like(other: Any, escape: str | None = None) → ColumnOperators

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

实现like运算符。

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

a LIKE other

例如：

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

参数：

• other – 要比较的表达式
  
• escape –
  可选的转义字符，呈现ESCAPE关键字，例如：

somecolumn.like("foo/%bar", escape="/")

另请参阅

ColumnOperators.ilike()

attribute local_attr

继承自 AssociationProxyInstance.local_attr 属性的 AssociationProxyInstance

此AssociationProxyInstance引用的“local”类属性。

另请参阅

AssociationProxyInstance.attr

AssociationProxyInstance.remote_attr

method match(other: Any, **kwargs: Any) → ColumnOperators

继承自 ColumnOperators.match() 方法的 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 兼容。
  

method not_ilike(other: Any, escape: str | None = None) → ColumnOperators

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

实现NOT ILIKE运算符。

这等同于使用ColumnOperators.ilike()进行否定，即~x.ilike(y)。

从 1.4 版更改：not_ilike()运算符在先前版本中从notilike()重命名。以确保向后兼容性，之前的名称仍可用。

另请参见

ColumnOperators.ilike()

method not_in(other: Any) → ColumnOperators

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

实现NOT IN运算符。

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

在other为空序列的情况下，编译器会生成一个“空的 not in”表达式。默认情况下，这会产生表达式“1 = 1”，以在所有情况下生成 true。可以使用create_engine.empty_in_strategy来修改此行为。

从 1.4 版更改：not_in()运算符在先前版本中从notin_()重命名。以确保向后兼容性，之前的名称仍可用。

从版本 1.2 开始更改：ColumnOperators.in_()和ColumnOperators.not_in()运算符现在默认生成空 IN 序列的“静态”表达式。

另请参阅

ColumnOperators.in_()

method not_like(other: Any, escape: str | None = None) → ColumnOperators

从 ColumnOperators.not_like() 方法继承的 ColumnOperators

实现NOT LIKE运算符。

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

从版本 1.4 开始更改：not_like()运算符从之前的发布中的notlike()重新命名。以前的名称保留用于向后兼容。

另请参阅

ColumnOperators.like()

method notilike(other: Any, escape: str | None = None) → ColumnOperators

从 ColumnOperators.notilike() 方法继承的 ColumnOperators

实现NOT ILIKE运算符。

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

从版本 1.4 开始更改：not_ilike()运算符从之前的发布中的notilike()重新命名。以前的名称保留用于向后兼容。

另请参阅

ColumnOperators.ilike()

method notin_(other: Any) → ColumnOperators

从 ColumnOperators.notin_() 方法继承的 ColumnOperators

实现NOT IN运算符。

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

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

从版本 1.4 起更改：not_in() 操作符从以前的版本中的 notin_() 重命名。以前的名称仍可用于向后兼容性。

从版本 1.2 起更改：ColumnOperators.in_() 和 ColumnOperators.not_in() 操作符现在默认情况下为一个空的 IN 序列生成一个 “静态” 表达式。

另请参阅

ColumnOperators.in_()

method notlike(other: Any, escape: str | None = None) → ColumnOperators

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

实现 NOT LIKE 操作符。

这等同于使用 ColumnOperators.like() 的否定，即 ~x.like(y)。

从版本 1.4 起更改：not_like() 操作符从以前的版本中的 notlike() 重命名。以前的名称仍可用于向后兼容性。

另请参阅

ColumnOperators.like()

method nulls_first() → ColumnOperators

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

对父对象生成一个 nulls_first() 子句。

从版本 1.4 起更改：nulls_first() 操作符从以前的版本中的 nullsfirst() 重命名。以前的名称仍可用于向后兼容性。

method nulls_last() → ColumnOperators

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

对父对象生成一个nulls_last()子句。

从版本 1.4 开始更改：nulls_last() 操作符从之前的发布中的 nullslast() 改名。 以前的名称仍然可用于向后兼容。

method nullsfirst() → ColumnOperators

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

对父对象生成一个nulls_first()子句。

从版本 1.4 开始更改：nulls_first() 操作符从之前的发布中的 nullsfirst() 改名。 以前的名称仍然可用于向后兼容。

method nullslast() → ColumnOperators

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

对父对象生成一个nulls_last()子句。

从版本 1.4 开始更改：nulls_last() 操作符从之前的发布中的 nullslast() 改名。 以前的名称仍然可用于向后兼容。

method 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.op() 方法的 Operators

生成一个通用操作函数。

例如：

somecolumn.op("*")(5)

产生：

somecolumn * 5

这个函数也可以用来使位运算符明确。 例如：

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

是 somecolumn 中的值的按位 AND。

参数：

• opstring – 将作为这个元素与传递给生成函数的表达式之间的中缀运算符输出的字符串。
  
• precedence –
  数据库预计在 SQL 表达式中应用到运算符的优先级。 这个整数值作为 SQL 编译器的提示，用于了解何时应在特定操作周围呈现显式括号。 较低的数字将导致将表达式与具有较高优先级的另一个运算符应用时加括号。 默认值为 0，低于所有运算符，除了逗号（,）和 AS 运算符。 值为 100 将高于或等于所有运算符，而 -100 将低于或等于所有运算符。
  另请参阅
  我正在使用 op() 生成自定义操作符，但我的括号没有正确输出 - SQLAlchemy SQL 编译器如何渲染括号的详细说明
  
• is_comparison –
  旧式的；如果为 True，则将该操作符视为“比较”操作符，即评估为布尔真/假值，如 ==、> 等。提供此标志是为了使 ORM 关系能够在自定义连接条件中使用操作符时确定操作符是比较操作符。
  使用 is_comparison 参数已被使用 Operators.bool_op() 方法取代；这个更简洁的操作符会自动设置该参数，但同时还提供了正确的PEP 484类型支持，因为返回的对象将表示“布尔”数据类型，即 BinaryExpression[bool]。
  
• return_type – 一个TypeEngine 类或对象，它将强制此操作符生成的表达式的返回类型为该类型。缺省情况下，指定 Operators.op.is_comparison 的操作符将解析为 Boolean，而不指定的操作符将与左操作数具有相同的类型。
  
• python_impl –
  可选的  Python 函数，可以在数据库服务器上运行时以相同的方式评估两个 Python 值的操作符。对于在 Python 中进行 SQL  表达式评估函数（例如用于 ORM 混合属性的函数）以及在多行更新或删除后用于匹配会话中的对象的 ORM “评估器”非常有用。
  例如：

>>> expr = column('x').op('+', python_impl=lambda a, b: a + b)('y')

• 上述表达式的操作符也将适用于非 SQL 的左右对象：

>>> expr.operator(5, 10)
15

• 2.0 版中的新功能。

另请参阅

Operators.bool_op()

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

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

method operate(op: OperatorType, *other: Any, **kwargs: Any) → ColumnElement[Any]

对参数进行操作。

这是操作的最低级别，缺省情况下会引发 NotImplementedError。

在子类上重写此功能可以使常见行为应用于所有操作。例如，重写 ColumnOperators 来应用 func.lower() 到左右两侧：

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

参数：

• op – 操作符可调用。
  
• *other – 操作的‘另一’方。对于大多数操作，它将是一个标量值。
  
• **kwargs – 修饰符。这些可以由特殊运算符如 ColumnOperators.contains() 传递。
  

method regexp_match(pattern: Any, flags: str | None = 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、PostgreSQL、MySQL 和 MariaDB 中实现。对于 SQLite，部分支持可用。第三方方言中的支持可能有所不同。

参数：

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

版本 1.4 中的新功能。

在版本 1.4.48 中更改为：2.0.18 请注意，由于实现错误，“flags” 参数先前接受�� SQL  表达式对象，例如列表达式，除了普通的 Python 字符串。这种实现与缓存不兼容，并已移除；“flags”  参数应仅传递字符串，因为这些标志将作为 SQL 表达式中的文字内联值呈现。

另请参见

ColumnOperators.regexp_replace()

method regexp_replace(pattern: Any, replacement: Any, flags: str | None = 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、PostgreSQL、MySQL 8 或更高版本以及 MariaDB。第三方方言中的支持可能有所不同。

参数：

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

版本 1.4 中的新功能。

从版本 1.4.48 更改为：2.0.18 请注意，由于实现错误，以前的“flags”参数接受了 SQL  表达式对象，例如列表达式，而不仅仅是普通的 Python  字符串。这种实现与缓存不兼容，并已删除；应该仅传递字符串作为“flags”参数，因为这些标志将作为 SQL 表达式中的文字内联值呈现。

另请参阅

ColumnOperators.regexp_match()

attribute remote_attr

继承自 AssociationProxyInstance.remote_attr 属性的 AssociationProxyInstance

被此 AssociationProxyInstance 引用的“remote”类属性。

另请参阅

AssociationProxyInstance.attr

AssociationProxyInstance.local_attr

method reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → Operators

继承自 Operators.reverse_operate() 方法的 Operators

对参数执行反向操作。

用法与 operate() 相同。

attribute scalar

继承自 AssociationProxyInstance.scalar 属性的 AssociationProxyInstance

如果此 AssociationProxyInstance 代理了本地端的标量关系，则返回True。

method startswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

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

实现startswith操作符。

生成一个 LIKE 表达式，用于测试字符串值的开头匹配：

column LIKE <other> || '%'

例如：

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

由于操作符使用LIKE，在表达式中存在的通配符字符"%"和"_"也将像通配符一样起作用。对于字面字符串值，可以将ColumnOperators.startswith.autoescape标志设置为True，以将这些字符在字符串值中的出现转义，使它们作为自身而不是通配符字符进行匹配。或者，ColumnOperators.startswith.escape参数将建立给定字符作为转义字符，这在目标表达式不是字面字符串时可能会有用。

参数：

• other – 要进行比较的表达式。通常这是一个纯字符串值，但也可以是任意的 SQL 表达式。LIKE 通配符字符%和_默认情况下不会被转义，除非设置了ColumnOperators.startswith.autoescape标志为 True。
  
• autoescape –
  boolean；当为 True 时，在 LIKE 表达式中建立转义字符，然后将其应用于比较值中的所有"%"、"_"和转义字符本身的出现，假定比较值是一个字面字符串而不是 SQL 表达式。
  诸如：

somecolumn.startswith("foo%bar", autoescape=True)

• 将呈现为：

somecolumn LIKE :param || '%' ESCAPE '/'

• 其值为:param，为"foo/%bar"。
• escape –
  一个字符，当给定时将使用ESCAPE关键字来将该字符设定为转义字符。然后可以将此字符放置在%和_的前面，以允许它们作为自身而不是通配符字符。
  诸如：

somecolumn.startswith("foo/%bar", escape="^")

• 将呈现为：

somecolumn LIKE :param || '%' ESCAPE '^'

• 该参数也可以与ColumnOperators.startswith.autoescape结合使用：

somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True)

• 在上述情况下，给定的文字参数将在传递到数据库之前转换为"foo^%bar^^bat"。

另请参见

ColumnOperators.endswith()

ColumnOperators.contains()

ColumnOperators.like()

attribute target_class: Type[Any]

由此AssociationProxyInstance处理的中间类。

拦截附加/设置/赋值事件将导致生成此类的新实例。

attribute timetuple: Literal[None] = None

继承自 ColumnOperators.timetuple 属性的 ColumnOperators 类

Hack，允许在左侧比较日期时间对象。

class sqlalchemy.ext.associationproxy.AssociationProxyExtensionType

一个枚举。

成员

ASSOCIATION_PROXY

类签名

类sqlalchemy.ext.associationproxy.AssociationProxyExtensionType (sqlalchemy.orm.base.InspectionAttrExtensionType)

attribute ASSOCIATION_PROXY = 'ASSOCIATION_PROXY'

表示一个InspectionAttr的符号，其类型为AssociationProxy。

被分配给InspectionAttr.extension_type属性。

tors.not_in()*方法的*ColumnOperators`

实现NOT IN运算符。

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

在other为空序列的情况下，编译器会生成一个“空的 not in”表达式。默认情况下，这会产生表达式“1 = 1”，以在所有情况下生成 true。可以使用create_engine.empty_in_strategy来修改此行为。

从 1.4 版更改：not_in()运算符在先前版本中从notin_()重命名。以确保向后兼容性，之前的名称仍可用。

从版本 1.2 开始更改：ColumnOperators.in_()和ColumnOperators.not_in()运算符现在默认生成空 IN 序列的“静态”表达式。

另请参阅

ColumnOperators.in_()

method not_like(other: Any, escape: str | None = None) → ColumnOperators

从 ColumnOperators.not_like() 方法继承的 ColumnOperators

实现NOT LIKE运算符。

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

从版本 1.4 开始更改：not_like()运算符从之前的发布中的notlike()重新命名。以前的名称保留用于向后兼容。

另请参阅

ColumnOperators.like()

method notilike(other: Any, escape: str | None = None) → ColumnOperators

从 ColumnOperators.notilike() 方法继承的 ColumnOperators

实现NOT ILIKE运算符。

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

从版本 1.4 开始更改：not_ilike()运算符从之前的发布中的notilike()重新命名。以前的名称保留用于向后兼容。

另请参阅

ColumnOperators.ilike()

method notin_(other: Any) → ColumnOperators

从 ColumnOperators.notin_() 方法继承的 ColumnOperators

实现NOT IN运算符。

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

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

从版本 1.4 起更改：not_in() 操作符从以前的版本中的 notin_() 重命名。以前的名称仍可用于向后兼容性。

从版本 1.2 起更改：ColumnOperators.in_() 和 ColumnOperators.not_in() 操作符现在默认情况下为一个空的 IN 序列生成一个 “静态” 表达式。

另请参阅

ColumnOperators.in_()

method notlike(other: Any, escape: str | None = None) → ColumnOperators

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

实现 NOT LIKE 操作符。

这等同于使用 ColumnOperators.like() 的否定，即 ~x.like(y)。

从版本 1.4 起更改：not_like() 操作符从以前的版本中的 notlike() 重命名。以前的名称仍可用于向后兼容性。

另请参阅

ColumnOperators.like()

method nulls_first() → ColumnOperators

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

对父对象生成一个 nulls_first() 子句。

从版本 1.4 起更改：nulls_first() 操作符从以前的版本中的 nullsfirst() 重命名。以前的名称仍可用于向后兼容性。

method nulls_last() → ColumnOperators

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

对父对象生成一个nulls_last()子句。

从版本 1.4 开始更改：nulls_last() 操作符从之前的发布中的 nullslast() 改名。 以前的名称仍然可用于向后兼容。

method nullsfirst() → ColumnOperators

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

对父对象生成一个nulls_first()子句。

从版本 1.4 开始更改：nulls_first() 操作符从之前的发布中的 nullsfirst() 改名。 以前的名称仍然可用于向后兼容。

method nullslast() → ColumnOperators

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

对父对象生成一个nulls_last()子句。

从版本 1.4 开始更改：nulls_last() 操作符从之前的发布中的 nullslast() 改名。 以前的名称仍然可用于向后兼容。

method 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.op() 方法的 Operators

生成一个通用操作函数。

例如：

somecolumn.op("*")(5)

产生：

somecolumn * 5

这个函数也可以用来使位运算符明确。 例如：

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

是 somecolumn 中的值的按位 AND。

参数：

• opstring – 将作为这个元素与传递给生成函数的表达式之间的中缀运算符输出的字符串。
  
• precedence –
  数据库预计在 SQL 表达式中应用到运算符的优先级。 这个整数值作为 SQL 编译器的提示，用于了解何时应在特定操作周围呈现显式括号。 较低的数字将导致将表达式与具有较高优先级的另一个运算符应用时加括号。 默认值为 0，低于所有运算符，除了逗号（,）和 AS 运算符。 值为 100 将高于或等于所有运算符，而 -100 将低于或等于所有运算符。
  另请参阅
  我正在使用 op() 生成自定义操作符，但我的括号没有正确输出 - SQLAlchemy SQL 编译器如何渲染括号的详细说明
  
• is_comparison –
  旧式的；如果为 True，则将该操作符视为“比较”操作符，即评估为布尔真/假值，如 ==、> 等。提供此标志是为了使 ORM 关系能够在自定义连接条件中使用操作符时确定操作符是比较操作符。
  使用 is_comparison 参数已被使用 Operators.bool_op() 方法取代；这个更简洁的操作符会自动设置该参数，但同时还提供了正确的PEP 484类型支持，因为返回的对象将表示“布尔”数据类型，即 BinaryExpression[bool]。
  
• return_type – 一个TypeEngine 类或对象，它将强制此操作符生成的表达式的返回类型为该类型。缺省情况下，指定 Operators.op.is_comparison 的操作符将解析为 Boolean，而不指定的操作符将与左操作数具有相同的类型。
  
• python_impl –
  可选的  Python 函数，可以在数据库服务器上运行时以相同的方式评估两个 Python 值的操作符。对于在 Python 中进行 SQL  表达式评估函数（例如用于 ORM 混合属性的函数）以及在多行更新或删除后用于匹配会话中的对象的 ORM “评估器”非常有用。
  例如：

>>> expr = column('x').op('+', python_impl=lambda a, b: a + b)('y')

• 上述表达式的操作符也将适用于非 SQL 的左右对象：

>>> expr.operator(5, 10)
15

• 2.0 版中的新功能。

另请参阅

Operators.bool_op()

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

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

method operate(op: OperatorType, *other: Any, **kwargs: Any) → ColumnElement[Any]

对参数进行操作。

这是操作的最低级别，缺省情况下会引发 NotImplementedError。

在子类上重写此功能可以使常见行为应用于所有操作。例如，重写 ColumnOperators 来应用 func.lower() 到左右两侧：

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

参数：

• op – 操作符可调用。
  
• *other – 操作的‘另一’方。对于大多数操作，它将是一个标量值。
  
• **kwargs – 修饰符。这些可以由特殊运算符如 ColumnOperators.contains() 传递。
  

method regexp_match(pattern: Any, flags: str | None = 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、PostgreSQL、MySQL 和 MariaDB 中实现。对于 SQLite，部分支持可用。第三方方言中的支持可能有所不同。

参数：

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

版本 1.4 中的新功能。

在版本 1.4.48 中更改为：2.0.18 请注意，由于实现错误，“flags” 参数先前接受�� SQL  表达式对象，例如列表达式，除了普通的 Python 字符串。这种实现与缓存不兼容，并已移除；“flags”  参数应仅传递字符串，因为这些标志将作为 SQL 表达式中的文字内联值呈现。

另请参见

ColumnOperators.regexp_replace()

method regexp_replace(pattern: Any, replacement: Any, flags: str | None = 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、PostgreSQL、MySQL 8 或更高版本以及 MariaDB。第三方方言中的支持可能有所不同。

参数：

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

版本 1.4 中的新功能。

从版本 1.4.48 更改为：2.0.18 请注意，由于实现错误，以前的“flags”参数接受了 SQL  表达式对象，例如列表达式，而不仅仅是普通的 Python  字符串。这种实现与缓存不兼容，并已删除；应该仅传递字符串作为“flags”参数，因为这些标志将作为 SQL 表达式中的文字内联值呈现。

另请参阅

ColumnOperators.regexp_match()

attribute remote_attr

继承自 AssociationProxyInstance.remote_attr 属性的 AssociationProxyInstance

被此 AssociationProxyInstance 引用的“remote”类属性。

另请参阅

AssociationProxyInstance.attr

AssociationProxyInstance.local_attr

method reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → Operators

继承自 Operators.reverse_operate() 方法的 Operators

对参数执行反向操作。

用法与 operate() 相同。

attribute scalar

继承自 AssociationProxyInstance.scalar 属性的 AssociationProxyInstance

如果此 AssociationProxyInstance 代理了本地端的标量关系，则返回True。

method startswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

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

实现startswith操作符。

生成一个 LIKE 表达式，用于测试字符串值的开头匹配：

column LIKE <other> || '%'

例如：

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

由于操作符使用LIKE，在表达式中存在的通配符字符"%"和"_"也将像通配符一样起作用。对于字面字符串值，可以将ColumnOperators.startswith.autoescape标志设置为True，以将这些字符在字符串值中的出现转义，使它们作为自身而不是通配符字符进行匹配。或者，ColumnOperators.startswith.escape参数将建立给定字符作为转义字符，这在目标表达式不是字面字符串时可能会有用。

参数：

• other – 要进行比较的表达式。通常这是一个纯字符串值，但也可以是任意的 SQL 表达式。LIKE 通配符字符%和_默认情况下不会被转义，除非设置了ColumnOperators.startswith.autoescape标志为 True。
  
• autoescape –
  boolean；当为 True 时，在 LIKE 表达式中建立转义字符，然后将其应用于比较值中的所有"%"、"_"和转义字符本身的出现，假定比较值是一个字面字符串而不是 SQL 表达式。
  诸如：

somecolumn.startswith("foo%bar", autoescape=True)

• 将呈现为：

somecolumn LIKE :param || '%' ESCAPE '/'

• 其值为:param，为"foo/%bar"。
• escape –
  一个字符，当给定时将使用ESCAPE关键字来将该字符设定为转义字符。然后可以将此字符放置在%和_的前面，以允许它们作为自身而不是通配符字符。
  诸如：

somecolumn.startswith("foo/%bar", escape="^")

• 将呈现为：

somecolumn LIKE :param || '%' ESCAPE '^'

• 该参数也可以与ColumnOperators.startswith.autoescape结合使用：

somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True)

• 在上述情况下，给定的文字参数将在传递到数据库之前转换为"foo^%bar^^bat"。

另请参见

ColumnOperators.endswith()

ColumnOperators.contains()

ColumnOperators.like()

attribute target_class: Type[Any]

由此AssociationProxyInstance处理的中间类。

拦截附加/设置/赋值事件将导致生成此类的新实例。

attribute timetuple: Literal[None] = None

继承自 ColumnOperators.timetuple 属性的 ColumnOperators 类

Hack，允许在左侧比较日期时间对象。

class sqlalchemy.ext.associationproxy.AssociationProxyExtensionType

一个枚举。

成员

ASSOCIATION_PROXY

类签名

类sqlalchemy.ext.associationproxy.AssociationProxyExtensionType (sqlalchemy.orm.base.InspectionAttrExtensionType)

attribute ASSOCIATION_PROXY = 'ASSOCIATION_PROXY'

表示一个InspectionAttr的符号，其类型为AssociationProxy。

被分配给InspectionAttr.extension_type属性。