SQLAlchemy 1.4 Documentation

类签名

class sqlalchemy.orm.ColumnProperty.Comparator (sqlalchemy.util.langhelpers.MemoizedSlots, sqlalchemy.orm.PropComparator)

method sqlalchemy.orm.ColumnProperty.Comparator.operate(op, *other, **kwargs)¶

对参数进行运算。

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

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

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

参数

op¶ -- 操作员可调用。
*other¶ -- 操作的“另一方”。对于大多数操作，将是单个标量。
**kwargs¶ -- 修饰语。这些可由特殊操作员通过，如 ColumnOperators.contains() .

method sqlalchemy.orm.ColumnProperty.Comparator.reverse_operate(op, other, **kwargs)¶

对参数进行反向运算。

用法与 operate() .

method sqlalchemy.orm.ColumnProperty.__init__(*columns, **kwargs)¶

构建新的 ColumnProperty 对象。

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

method sqlalchemy.orm.ColumnProperty.do_init()¶

执行子类特定的初始化后映射器创建步骤。

这是由 MapperProperty 对象的init（）方法。

attribute sqlalchemy.orm.ColumnProperty.expression¶

返回此ColumnProperty的主列或表达式。

例如。：：

class File(Base):
    # ...

    name = Column(String(64))
    extension = Column(String(8))
    filename = column_property(name + '.' + extension)
    path = column_property('C:/' + filename.expression)

参见

在映射时从列属性合成

method sqlalchemy.orm.ColumnProperty.instrument_class(mapper)¶

映射器调用该属性以启动由该映射器属性管理的类属性的检测。

这里的mapperproperty通常会调用attributes模块来设置instructedAttribute。

此步骤是设置InstrumentedAttribute的两个步骤中的第一个步骤，在映射器设置过程的早期调用。

第二步通常是init_class_属性步骤，通过post_instrument_class（）钩子从strategizedproperty调用。此步骤将附加状态分配给InstrumentedAttribute（特别是“impl”），该属性是在MapperProperty确定需要执行哪种持久性管理（例如标量、对象、集合等）之后确定的。

method sqlalchemy.orm.ColumnProperty.merge(session, source_state, source_dict, dest_state, dest_dict, load, _recursive, _resolve_conflict_map)¶: 合并此表示的属性 MapperProperty 从源对象到目标对象。

class sqlalchemy.orm.CompositeProperty(class_, *attrs, **kwargs)¶

定义一个“复合”映射属性，将列集合表示为一个属性。

CompositeProperty 是使用 composite() 功能。

参见

组合列类型

类签名

class sqlalchemy.orm.CompositeProperty (sqlalchemy.orm.descriptor_props.DescriptorProperty)

class Comparator(prop, parentmapper, adapt_to_entity=None)¶

为生成布尔、比较和其他运算符 CompositeProperty 属性。

参见中的示例重新定义复合材料的比较操作有关用法的概述，以及 PropComparator .

参见

PropComparator

ColumnOperators

Mapper.all_orm_descriptors

类签名

class sqlalchemy.orm.CompositeProperty.Comparator (sqlalchemy.orm.PropComparator)

class CompositeBundle(property_, expr)¶

类签名

class sqlalchemy.orm.CompositeProperty.CompositeBundle (sqlalchemy.orm.Bundle)

method sqlalchemy.orm.CompositeProperty.CompositeBundle.create_row_processor(query, procs, labels)¶

为此生成“行处理”函数 Bundle .

可以被子类重写。

参见

列束 -包括子类化的示例。

method sqlalchemy.orm.CompositeProperty.__init__(class_, *attrs, **kwargs)¶

构建新的 CompositeProperty 对象。

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

method sqlalchemy.orm.CompositeProperty.do_init()¶: 在 CompositeProperty 已与其父映射器关联。

method sqlalchemy.orm.CompositeProperty.get_history(state, dict_, passive=symbol('PASSIVE_OFF'))¶: 为使用attributes.get_history（）的userland代码提供。

method sqlalchemy.orm.CompositeProperty.instrument_class(mapper)¶

映射器调用该属性以启动由该映射器属性管理的类属性的检测。

这里的mapperproperty通常会调用attributes模块来设置instructedAttribute。

此步骤是设置InstrumentedAttribute的两个步骤中的第一个步骤，在映射器设置过程的早期调用。

class sqlalchemy.orm.AttributeEvent(attribute_impl, op)¶

在属性事件链的整个过程中传播的令牌。

作为事件源的指示器，还提供了控制跨属性操作链传播的方法。

这个 Event 对象作为 initiator 处理诸如 AttributeEvents.append() ， AttributeEvents.set() 和 AttributeEvents.remove() .

这个 Event 对象当前由backref事件处理程序解释，用于控制操作在两个相互依赖的属性之间的传播。

0.9.0 新版功能.

属性impl: 这个 AttributeImpl 它是当前事件发起程序。
属性操作: 符号 OP_APPEND ， OP_REMOVE ， OP_REPLACE 或 OP_BULK_REPLACE ，指示源操作。

class sqlalchemy.orm.IdentityMap¶

method sqlalchemy.orm.IdentityMap.check_modified()¶: 如果存在任何InstanceStates已标记为“Modified”，则返回true。

class sqlalchemy.orm.InspectionAttr¶

应用于可以由返回的所有ORM对象的基类 inspect() 功能。

这里定义的属性允许使用简单的布尔检查来测试返回对象的基本事实。

虽然这里的布尔检查基本上与使用python isinstance（）函数相同，但是这里的标志可以在不需要导入所有这些类的情况下使用，而且还可以在保持标志不变的情况下更改sqlachemy类系统，以实现前向兼容性。

attribute sqlalchemy.orm.InspectionAttr.extension_type = symbol('NOT_EXTENSION')¶: 扩展类型（如果有）。默认为 NOT_EXTENSION

参见

HYBRID_METHOD

HYBRID_PROPERTY

ASSOCIATION_PROXY

attribute sqlalchemy.orm.InspectionAttr.is_aliased_class = False¶: 如果此对象是 AliasedClass .

attribute sqlalchemy.orm.InspectionAttr.is_attribute = False¶

如果此对象是python，则为true descriptor .

这可以指许多类型中的一种。通常是 QueryableAttribute 它代表 MapperProperty . 但也可以是扩展类型，例如 AssociationProxy 或 hybrid_property . 这个 InspectionAttr.extension_type 将引用标识特定子类型的常量。

参见

attribute sqlalchemy.orm.InspectionAttr.is_bundle = False¶: 如果此对象是 Bundle .

attribute sqlalchemy.orm.InspectionAttr.is_clause_element = False¶: 如果此对象是 ClauseElement .

attribute sqlalchemy.orm.InspectionAttr.is_instance = False¶: 如果此对象是 InstanceState .

attribute sqlalchemy.orm.InspectionAttr.is_mapper = False¶: 如果此对象是 Mapper .

attribute sqlalchemy.orm.InspectionAttr.is_property = False¶: 如果此对象是 MapperProperty .

attribute sqlalchemy.orm.InspectionAttr.is_selectable = False¶: 如果此对象是 Selectable .

class sqlalchemy.orm.InspectionAttrInfo¶

添加 .info 属性到 InspectionAttr .

原因 InspectionAttr VS InspectionAttrInfo 前者与指定类的mixin兼容吗？ __slots__ ；这本质上是一个实现工件。

类签名

class sqlalchemy.orm.InspectionAttrInfo (sqlalchemy.orm.base.InspectionAttr)

attribute sqlalchemy.orm.InspectionAttrInfo.info¶

与对象关联的信息字典，允许用户定义的数据与此关联 InspectionAttr .

字典在第一次访问时生成。或者，可以将其指定为 column_property() ， relationship() 或 composite() 功能。

在 1.0.0 版更改: MapperProperty.info 也可以通过 InspectionAttrInfo.info 属性，以便它可以应用于更广泛的ORM和扩展构造。

参见

QueryableAttribute.info

SchemaItem.info

class sqlalchemy.orm.InstanceState(obj, manager)¶

在实例级别跟踪状态信息。

这个 InstanceState 是SQLAlchemy窗体用来跟踪对象状态的键对象；它是在对象实例化时创建的，通常是由于 instrumentation 哪个SQL炼金术适用于 __init__() 类的方法。

InstanceState 也是一个半公共对象，可用于运行时检查映射实例的状态，包括特定实例中的当前状态等信息 Session 以及有关单个属性的数据的详细信息。公共API以获取 InstanceState 对象是使用 inspect() 系统：

>>> from sqlalchemy import inspect
>>> insp = inspect(some_mapped_object)

参见

运行时检查API

类签名

class sqlalchemy.orm.InstanceState (sqlalchemy.orm.base.InspectionAttrInfo)

attribute sqlalchemy.orm.InstanceState.async_session¶

归还所有权 AsyncSession 对于此实例，或者 None 如果没有可用的话。

此属性仅在以下情况下才为非None sqlalchemy.ext.asyncio 此ORM对象正在使用API。返回者 AsyncSession 对象将是 Session 对象，该对象将从 InstanceState.session 此属性的 InstanceState 。

1.4.18 新版功能.

参见

异步I/O（异步）

attribute sqlalchemy.orm.InstanceState.attrs¶

返回表示映射对象上每个属性的命名空间，包括其当前值和历史记录。

返回的对象是 AttributeState . 此对象允许检查属性中的当前数据以及自上次刷新以来的属性历史记录。

attribute sqlalchemy.orm.InstanceState.callables = ()¶

一个可以关联每状态加载程序可调用的命名空间。

在SQLAlchemy 1.0中，这仅用于通过查询选项设置的惰性加载程序/延迟加载程序。

以前，可调用文件还用于通过在此字典中存储指向InstanceState本身的链接来指示过期的属性。此角色现在由过期的属性集处理。

attribute sqlalchemy.orm.InstanceState.deleted¶

返回 True 如果对象是 deleted .

保证处于已删除状态的对象不在 Session.identity_map 它的父母 Session ；但是，如果回滚会话的事务，则对象将恢复到持久状态和标识映射。

注解

这个 InstanceState.deleted 属性是指在“持久”和“分离”状态之间发生的对象的特定状态；一旦对象 detached , the InstanceState.deleted 属性 不再返回真 ；以检测是否已删除状态，无论对象是否与 Session 使用 InstanceState.was_deleted 访问器。

参见

Quickie对象状态简介

attribute sqlalchemy.orm.InstanceState.detached¶: 返回 True 如果对象是 detached .

参见

Quickie对象状态简介

attribute sqlalchemy.orm.InstanceState.dict¶

返回对象使用的实例dict。

在正常情况下，这始终是 __dict__ 映射对象的属性，除非配置了其他检测系统。

在实际对象被垃圾收集的情况下，此访问器返回一个空字典。

attribute sqlalchemy.orm.InstanceState.expired_attributes = None¶

“过期”的一组键，由管理器的延迟标量加载程序加载，假定没有挂起的更改。

也见 unmodified 刷新操作发生时与此集合相交的集合。

attribute sqlalchemy.orm.InstanceState.has_identity¶

返回 True 如果此对象具有标识密钥。

它的值应始终与表达式的值相同 state.persistent 或 state.detached .

attribute sqlalchemy.orm.InstanceState.identity¶

返回映射对象的映射标识。这是ORM持久化的主键标识，可以直接传递给 Query.get() .

返回 None 如果对象没有主键标识。

注解

一个物体，它是 transient 或 pending 做 not 在刷新之前拥有一个映射的标识，即使其属性包含主键值也是如此。

attribute sqlalchemy.orm.InstanceState.identity_key¶

返回映射对象的标识键。

这是用于在 Session.identity_map 映射。它包含返回的标识 identity 在它里面。

attribute sqlalchemy.orm.InstanceState.mapper¶: 返回 Mapper 用于此映射对象。

attribute sqlalchemy.orm.InstanceState.object¶: 返回由此表示的映射对象 InstanceState .

attribute sqlalchemy.orm.InstanceState.pending¶: 返回 True 如果对象是 pending .

参见

Quickie对象状态简介

attribute sqlalchemy.orm.InstanceState.persistent¶

返回 True 如果对象是 persistent .

处于持久状态的对象保证位于 Session.identity_map 它的父母 Session .

在 1.1 版更改: 这个 InstanceState.persistent 对于在刷新过程中被“删除”的对象，访问器不再返回true；请使用 InstanceState.deleted 用于检测此状态的访问器。这允许“持久”状态确保身份映射中的成员身份。

参见

Quickie对象状态简介

attribute sqlalchemy.orm.InstanceState.session¶

归还拥有者 Session 在这种情况下，或 None 如果没有。

注意，这里的结果在某些情况下可能是 不同的 从那 obj in session ；已删除的对象将报告为非 in session 但是，如果事务仍在进行中，则此属性仍将引用该会话。只有当事务完成时，对象才会在正常情况下完全分离。

参见

InstanceState.async_session

attribute sqlalchemy.orm.InstanceState.transient¶: 返回 True 如果对象是 transient .

参见

Quickie对象状态简介

attribute sqlalchemy.orm.InstanceState.unloaded¶

返回一组没有加载值的键。

这包括过期的属性和任何其他从未填充或修改的属性。

attribute sqlalchemy.orm.InstanceState.unloaded_expirable¶

返回一组没有加载值的键。

这包括过期的属性和任何其他从未填充或修改的属性。

attribute sqlalchemy.orm.InstanceState.unmodified¶: 返回没有未提交更改的密钥集

method sqlalchemy.orm.InstanceState.unmodified_intersection(keys)¶: 返回self.unmodified.intersection（keys）。

attribute sqlalchemy.orm.InstanceState.was_deleted¶

如果此对象当前或以前处于“已删除”状态且尚未还原为持久性，则返回true。

一旦对象在flush中被删除，此标志将返回true。当对象被显式地或通过事务提交从会话中删除并进入“分离”状态时，此标志将继续报告为真。

1.1 新版功能: -添加了本地方法形式 was_deleted() .

参见

InstanceState.deleted -指“已删除”状态

was_deleted() -独立函数

Quickie对象状态简介

class sqlalchemy.orm.InstrumentedAttribute(class_, key, parententity, impl=None, comparator=None, of_type=None, extra_criteria=())¶

类绑定的插入指令的属性，它添加了基本的 descriptor 方法。

见 QueryableAttribute 对于大多数功能的描述。

类签名

class sqlalchemy.orm.InstrumentedAttribute (sqlalchemy.orm.Mapped)

method sqlalchemy.orm.InstrumentedAttribute.__delete__(instance)¶

method sqlalchemy.orm.InstrumentedAttribute.__get__(instance, owner)¶

method sqlalchemy.orm.InstrumentedAttribute.__set__(instance, value)¶

sqlalchemy.orm.MANYTOONE = symbol('MANYTOONE')¶

指示多对一方向 relationship() .

此符号通常由内部使用，但可能在某些API功能中公开。

sqlalchemy.orm.MANYTOMANY = symbol('MANYTOMANY')¶

指示的多对多方向 relationship() .

此符号通常由内部使用，但可能在某些API功能中公开。

class sqlalchemy.orm.Mapped(class_, key, parententity, impl=None, comparator=None, of_type=None, extra_criteria=())¶

表示映射的ORM descriptor 属性用于键入。

此类表示任何类属性的完整描述符接口，这些属性将 instrumented 通过ORM Mapper 班级。当与类型存根一起使用时，它是类型检查器(如mypy)用来提供属性的完整行为约定的最后一个类型。

小技巧

这个 Mapped 类表示由 Mapper 班级。它不包括作为扩展提供的其他Python描述符类，包括混合属性以及关联代理。虽然这些系统仍然使用特定于ORM的超类和结构，但它们不是 instrumented 由 Mapper 取而代之的是在类上访问它们时提供它们自己的功能。

在使用 SQLAlchemy Mypy plugin ，即 Mapped 构造用于键入批注，以向插件指示那些预期映射的属性；该插件也适用 Mapped 中的声明性映射时，它会自动作为批注声明性表格风格。有关更多间接映射样式，如 imperative table 它通常显式应用于期望基于给定的 Table 配置。

Mapped 是在 sqlalchemy2-stubs 将项目作为 PEP 484 可以订阅任何任意Python类型的泛型类，该类型表示由以下属性处理的Python类型：：

class MyMappedClass(Base):
    __table_ = Table(
        "some_table", Base.metadata,
        Column("id", Integer, primary_key=True),
        Column("data", String(50)),
        Column("created_at", DateTime)
    )

    id : Mapped[int]
    data: Mapped[str]
    created_at: Mapped[datetime]

有关如何使用的完整背景信息，请参阅 Mapped 使用像Mypy这样的PEP-484工具，请参见下面的链接，了解SQLAlChemy的Mypy插件的背景。

1.4 新版功能.

参见

Mypy/Pep-484对ORM映射的支持 -有关Mypy集成的完整背景

类签名

class sqlalchemy.orm.Mapped (sqlalchemy.orm.QueryableAttribute, typing.Generic)

class sqlalchemy.orm.MapperProperty¶

表示由映射的特定类属性 Mapper .

最常见的 MapperProperty 是映射的 Column ，在映射中表示为 ColumnProperty 以及对由生成的另一类的引用 relationship() ，在映射中表示为 RelationshipProperty .

类签名

class sqlalchemy.orm.MapperProperty (sqlalchemy.sql.traversals.HasCacheKey, sqlalchemy.orm.base._MappedAttribute, sqlalchemy.orm.base.InspectionAttr, sqlalchemy.util.langhelpers.MemoizedSlots)

attribute sqlalchemy.orm.MapperProperty.info¶

与对象关联的信息字典，允许用户定义的数据与此关联 InspectionAttr .

字典在第一次访问时生成。或者，可以将其指定为 column_property() ， relationship() 或 composite() 功能。

在 1.0.0 版更改: InspectionAttr.info 移居 MapperProperty 这样它就可以应用于更广泛的ORM和扩展结构。

参见

QueryableAttribute.info

SchemaItem.info

attribute sqlalchemy.orm.MapperProperty.cascade = frozenset({})¶

“cascade”属性名称集。

在调用“cascadeu迭代器”方法之前，检查此集合。

集合通常只适用于RelationshipProperty。

method sqlalchemy.orm.MapperProperty.cascade_iterator(type_, state, dict_, visited_states, halt_on=None)¶

从这个mapperproperty开始，循环访问与特定“cascade”的给定实例相关的实例。

返回迭代器3元组（实例、映射器、状态）。

请注意，在调用Cascade_迭代器之前，首先检查此MapperProperty上给定类型的“Cascade”集合。

此方法通常只适用于RelationshipProperty。

attribute sqlalchemy.orm.MapperProperty.class_attribute¶

返回与此对应的类绑定描述符 MapperProperty .

这基本上是一个 getattr() 呼叫：

return getattr(self.parent.class_, self.key)

即，如果 MapperProperty 被命名 addresses ，它映射到的类是 User ，此序列是可能的：

>>> from sqlalchemy import inspect
>>> mapper = inspect(User)
>>> addresses_property = mapper.attrs.addresses
>>> addresses_property.class_attribute is User.addresses
True
>>> User.addresses.property is addresses_property
True

method sqlalchemy.orm.MapperProperty.create_row_processor(context, query_entity, path, mapper, result, adapter, populators)¶: 生成行处理函数并附加到给定的填充器列表集。

method sqlalchemy.orm.MapperProperty.do_init()¶

执行子类特定的初始化后映射器创建步骤。

这是由 MapperProperty 对象的init（）方法。

method sqlalchemy.orm.MapperProperty.init()¶: 在创建所有映射器之后调用，以组装映射器之间的关系并执行其他后期映射器创建初始化步骤。

method sqlalchemy.orm.MapperProperty.instrument_class(mapper)¶

映射器调用该属性以启动由该映射器属性管理的类属性的检测。

这里的mapperproperty通常会调用attributes模块来设置instructedAttribute。

此步骤是设置InstrumentedAttribute的两个步骤中的第一个步骤，在映射器设置过程的早期调用。

attribute sqlalchemy.orm.MapperProperty.is_property = True¶: inspectionattr接口的一部分；说明此对象是映射器属性。

method sqlalchemy.orm.MapperProperty.merge(session, source_state, source_dict, dest_state, dest_dict, load, _recursive, _resolve_conflict_map)¶: 合并此表示的属性 MapperProperty 从源对象到目标对象。

method sqlalchemy.orm.MapperProperty.post_instrument_class(mapper)¶

执行init（）完成后需要进行的检测调整。

给定的映射器是调用操作的映射器，在继承方案中，该映射器可能与self.parent不同；但是，映射器将始终至少是self.parent的子映射器。

此方法通常由StrategizedProperty使用，它将其委托给loaderStrategy.init_class_attribute（）以对绑定到类的instructedAttribute执行最终设置。

method sqlalchemy.orm.MapperProperty.set_parent(parent, init)¶

设置引用此映射器属性的父映射器。

此方法被某些子类重写，以便在第一次知道映射器时执行额外的设置。

method sqlalchemy.orm.MapperProperty.setup(context, query_entity, path, adapter, **kwargs)¶

通过查询调用以构造SQL语句。

与目标映射器关联的每个映射器属性都处理查询上下文引用的语句，并根据需要添加列和/或条件。

sqlalchemy.orm.NOT_EXTENSION = symbol('NOT_EXTENSION')¶

符号表示 InspectionAttr 这不是sqlacalchemy.ext的一部分。

分配给 InspectionAttr.extension_type 属性。

function sqlalchemy.orm.merge_result(query, iterator, load=True)¶: 将结果合并到此 Query 对象的会话。

1.4 版后已移除: 这个 merge_result() 方法被 merge_frozen_result() 功能。（SQLAlchemy 2.0的背景：迁移到Alchemy ）

function sqlalchemy.orm.merge_frozen_result(session, statement, frozen_result, load=True)¶

合并a FrozenResult 回到一个 Session ，返回新的 Result 对象与 persistent 物体。

见剖面图重新执行语句举个例子。

参见

重新执行语句

Result.freeze()

FrozenResult

sqlalchemy.orm.ONETOMANY = symbol('ONETOMANY')¶

表示一对多方向 relationship() .

此符号通常由内部使用，但可能在某些API功能中公开。

class sqlalchemy.orm.PropComparator(prop, parentmapper, adapt_to_entity=None)¶

为定义SQL运算符 MapperProperty 物体。

SQLAlchemy允许在核心和ORM级别重新定义运算符。 PropComparator 是ORM级操作的运算符重定义的基类，包括 ColumnProperty ， RelationshipProperty 和 CompositeProperty .

注解

随着SQLAlchemy 0.7中引入的混合属性的出现，以及SQLAlchemy 0.8中的核心级运算符重新定义，用户定义的用例 PropComparator 实例非常罕见。见混合属性以及重新定义和创建新的运算符 .

用户定义的子类 PropComparator 可以创建。内置的python比较和数学运算符方法，例如 ColumnOperators.__eq__() ， ColumnOperators.__lt__() 和 ColumnOperators.__add__() 可以重写以提供新的运算符行为。习俗 PropComparator 传递给 MapperProperty 实例通过 comparator_factory 争论。在每种情况下， PropComparator 应使用：

# definition of custom PropComparator subclasses

from sqlalchemy.orm.properties import \
                        ColumnProperty,\
                        CompositeProperty,\
                        RelationshipProperty

class MyColumnComparator(ColumnProperty.Comparator):
    def __eq__(self, other):
        return self.__clause_element__() == other

class MyRelationshipComparator(RelationshipProperty.Comparator):
    def any(self, expression):
        "define the 'any' operation"
        # ...

class MyCompositeComparator(CompositeProperty.Comparator):
    def __gt__(self, other):
        "redefine the 'greater than' operation"

        return sql.and_(*[a>b for a, b in
                          zip(self.__clause_element__().clauses,
                              other.__composite_values__())])


# application of custom PropComparator subclasses

from sqlalchemy.orm import column_property, relationship, composite
from sqlalchemy import Column, String

class SomeMappedClass(Base):
    some_column = column_property(Column("some_column", String),
                        comparator_factory=MyColumnComparator)

    some_relationship = relationship(SomeOtherClass,
                        comparator_factory=MyRelationshipComparator)

    some_composite = composite(
            Column("a", String), Column("b", String),
            comparator_factory=MyCompositeComparator
        )

注意，对于列级运算符重新定义，通常使用 TypeEngine.comparator_factory 属性。见重新定义和创建新的运算符更多细节。

参见

Comparator

ColumnOperators

类签名

class sqlalchemy.orm.PropComparator (sqlalchemy.sql.expression.ColumnOperators)

method sqlalchemy.orm.PropComparator.__eq__(other)¶

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

实施 == 操作员。

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

method sqlalchemy.orm.PropComparator.__le__(other)¶

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

实施 <= 操作员。

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

method sqlalchemy.orm.PropComparator.__lt__(other)¶

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

实施 < 操作员。

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

method sqlalchemy.orm.PropComparator.__ne__(other)¶

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

实施 != 操作员。

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

method sqlalchemy.orm.PropComparator.adapt_to_entity(adapt_to_entity)¶: 返回此propComparator的副本，该副本将使用给定的 AliasedInsp 产生相应的表达式。

attribute sqlalchemy.orm.PropComparator.adapter¶: 生成一个可调用文件，使列表达式适应此比较器的别名版本。

method sqlalchemy.orm.PropComparator.all_()¶

inherited from the ColumnOperators.all_() method of ColumnOperators

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

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

注解

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

1.1 新版功能.

method sqlalchemy.orm.PropComparator.and_(*criteria)¶

向由此关系属性表示的ON子句添加其他条件。

例如。：：

stmt = select(User).join(
    User.addresses.and_(Address.email_address != 'foo')
)

stmt = select(User).options(
    joinedload(User.addresses.and_(Address.email_address != 'foo'))
)

1.4 新版功能.

参见

扩充内置ON子句

向加载程序选项添加条件

with_loader_criteria()

method sqlalchemy.orm.PropComparator.any(criterion=None, **kwargs)¶

如果此集合包含符合给定条件的任何成员，则返回true。

通常执行 any() 是 Comparator.any() .

参数

criterion¶ -- 针对成员类的表或属性制定的可选子句。
**kwargs¶ -- 对应于成员类属性名的键/值对，将通过相等于相应的值进行比较。

method sqlalchemy.orm.PropComparator.any_()¶

inherited from the ColumnOperators.any_() method of ColumnOperators

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

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

注解

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

1.1 新版功能.

method sqlalchemy.orm.PropComparator.asc()¶: inherited from the ColumnOperators.asc() method of ColumnOperators

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

method sqlalchemy.orm.PropComparator.between(cleft, cright, symmetric=False)¶: inherited from the ColumnOperators.between() method of ColumnOperators

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

method sqlalchemy.orm.PropComparator.bool_op(opstring, precedence=0)¶

inherited from the Operators.bool_op() method of Operators

返回自定义布尔运算符。

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

参见

Operators.op()

method sqlalchemy.orm.PropComparator.collate(collation)¶: inherited from the ColumnOperators.collate() method of ColumnOperators

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

参见

collate()

method sqlalchemy.orm.PropComparator.concat(other)¶

inherited from the ColumnOperators.concat() method of ColumnOperators

实现“concat”运算符。

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

method sqlalchemy.orm.PropComparator.contains(other, **kwargs)¶

inherited from the ColumnOperators.contains() method of ColumnOperators

实现“contains”运算符。

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

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

例如。：：

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

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

参数

other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.contains.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.包含（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param |‘%‘ESCAPE’/”，值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.contains（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.contains.autoescape ：：someColumn.contains（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

method sqlalchemy.orm.PropComparator.desc()¶: inherited from the ColumnOperators.desc() method of ColumnOperators

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

method sqlalchemy.orm.PropComparator.distinct()¶: inherited from the ColumnOperators.distinct() method of ColumnOperators

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

method sqlalchemy.orm.PropComparator.endswith(other, **kwargs)¶

inherited from the ColumnOperators.endswith() method of ColumnOperators

实现“endswith”运算符。

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

column LIKE '%' || <other>

例如。：：

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

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

参数

other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.endswith.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.endswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param ESCAPE“/”值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.endswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param ESCAPE '^' The parameter may also be combined with ColumnOperators.endswith.autoescape ：：someColumn.endsWith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

method sqlalchemy.orm.PropComparator.has(criterion=None, **kwargs)¶

如果此元素引用满足给定条件的成员，则返回true。

通常执行 has() 是 Comparator.has() .

参数

criterion¶ -- 针对成员类的表或属性制定的可选子句。
**kwargs¶ -- 对应于成员类属性名的键/值对，将通过相等于相应的值进行比较。

method sqlalchemy.orm.PropComparator.ilike(other, escape=None)¶

inherited from the ColumnOperators.ilike() method of ColumnOperators

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

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

lower(a) LIKE lower(other)

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

a ILIKE other

例如。：：

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

参数

other¶ -- 要比较的表达式
escape¶ -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.ilike（“foo/%bar”，escape=“/”）

参见

ColumnOperators.is_not()

method sqlalchemy.orm.PropComparator.in_(other)¶

inherited from the ColumnOperators.in_() method of ColumnOperators

实施 in 操作员。

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

给定参数 other 可能是：

文字值列表，例如：
```
stmt.where(column.in_([1, 2, 3]))
```
在此调用表单中，项目列表将转换为一组与给定列表长度相同的绑定参数：
```
WHERE COL IN (?, ?, ?)
```

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

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

空列表，例如：
```
stmt.where(column.in_([]))
```
在此调用形式中，表达式呈现“空集”表达式。这些表达式是针对各个后端量身定做的，通常会尝试将空的SELECT语句作为子查询。例如在SQLite上，表达式为：：
```
WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
在 1.4 版更改: 空IN表达式现在在所有情况下都使用生成的SELECT子查询的执行时间。
绑定参数，例如 bindparam() ，如果包含 bindparam.expanding 旗帜：
```
stmt.where(column.in_(bindparam('value', expanding=True)))
```
在此调用表单中，表达式呈现一个特殊的非SQL占位符表达式，其外观如下：
```
WHERE COL IN ([EXPANDING_value])
```
此占位符表达式在语句执行时被截取，以便转换为前面所示的绑定参数表单的变量号。如果语句的执行方式为：
```
connection.execute(stmt, {"value": [1, 2, 3]})
```
将为数据库传递每个值的绑定参数：
```
WHERE COL IN (?, ?, ?)
```
1.2 新版功能: 添加了“扩展”绑定参数

如果传递空列表，将呈现一个特定于正在使用的数据库的特殊“空列表”表达式。在sqlite上：
```
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
1.3 新版功能: “expanding”绑定参数现在支持空列表

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

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

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

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

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

method sqlalchemy.orm.PropComparator.is_(other)¶

inherited from the ColumnOperators.is_() method of ColumnOperators

实施 IS 操作员。

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

参见

method sqlalchemy.orm.PropComparator.is_distinct_from(other)¶

inherited from the ColumnOperators.is_distinct_from() method of ColumnOperators

实施 IS DISTINCT FROM 操作员。

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

1.1 新版功能.

method sqlalchemy.orm.PropComparator.is_not(other)¶

inherited from the ColumnOperators.is_not() method of ColumnOperators

实施 IS NOT 操作员。

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

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

参见

method sqlalchemy.orm.PropComparator.is_not_distinct_from(other)¶

inherited from the ColumnOperators.is_not_distinct_from() method of ColumnOperators

实施 IS NOT DISTINCT FROM 操作员。

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

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

1.1 新版功能.

method sqlalchemy.orm.PropComparator.isnot(other)¶

inherited from the ColumnOperators.isnot() method of ColumnOperators

实施 IS NOT 操作员。

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

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

参见

method sqlalchemy.orm.PropComparator.isnot_distinct_from(other)¶

inherited from the ColumnOperators.isnot_distinct_from() method of ColumnOperators

实施 IS NOT DISTINCT FROM 操作员。

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

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

1.1 新版功能.

method sqlalchemy.orm.PropComparator.like(other, escape=None)¶

inherited from the ColumnOperators.like() method of ColumnOperators

实施 like 操作员。

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

a LIKE other

例如。：：

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

参数

other¶ -- 要比较的表达式
escape¶ -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.like（“foo/%bar”，escape=“/”）

参见

method sqlalchemy.orm.PropComparator.match(other, **kwargs)¶

inherited from the ColumnOperators.match() method of ColumnOperators

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

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

PostgreSQL-呈现 x @@ to_tsquery(y)
MySQL -渲染器 MATCH (x) AGAINST (y IN BOOLEAN MODE)

参见

match -具有附加功能的MySQL特定构造。
Oracle-呈现 CONTAINS(x, y)
其他后端可能提供特殊的实现。
没有任何特殊实现的后端将发出“match”操作符。例如，这与sqlite兼容。

method sqlalchemy.orm.PropComparator.not_ilike(other, escape=None)¶

inherited from the ColumnOperators.not_ilike() method of ColumnOperators

实施 NOT ILIKE 操作员。

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

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

参见

method sqlalchemy.orm.PropComparator.not_in(other)¶

inherited from the ColumnOperators.not_in() method of ColumnOperators

实施 NOT IN 操作员。

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

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

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

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

参见

method sqlalchemy.orm.PropComparator.not_like(other, escape=None)¶

inherited from the ColumnOperators.not_like() method of ColumnOperators

实施 NOT LIKE 操作员。

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

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

参见

method sqlalchemy.orm.PropComparator.notilike(other, escape=None)¶

inherited from the ColumnOperators.notilike() method of ColumnOperators

实施 NOT ILIKE 操作员。

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

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

参见

method sqlalchemy.orm.PropComparator.notin_(other)¶

inherited from the ColumnOperators.notin_() method of ColumnOperators

实施 NOT IN 操作员。

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

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

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

参见

method sqlalchemy.orm.PropComparator.notlike(other, escape=None)¶

inherited from the ColumnOperators.notlike() method of ColumnOperators

实施 NOT LIKE 操作员。

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

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

参见

method sqlalchemy.orm.PropComparator.nulls_first()¶: inherited from the ColumnOperators.nulls_first() method of ColumnOperators

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

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

method sqlalchemy.orm.PropComparator.nulls_last()¶: inherited from the ColumnOperators.nulls_last() method of ColumnOperators

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

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

method sqlalchemy.orm.PropComparator.nullsfirst()¶: inherited from the ColumnOperators.nullsfirst() method of ColumnOperators

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

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

method sqlalchemy.orm.PropComparator.nullslast()¶: inherited from the ColumnOperators.nullslast() method of ColumnOperators

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

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

method sqlalchemy.orm.PropComparator.of_type(class_)¶

根据多态子类重新定义这个对象， with_polymorphic() 构造，或 aliased() 构造。

返回一个新的PropComparator，从中可以计算出进一步的条件。

例如。：：

query.join(Company.employees.of_type(Engineer)).\
   filter(Engineer.name=='foo')

参数: class_¶ -- 一个类或映射器，指示条件将针对这个特定的子类。

参见

在关系中引用特定的子类型

method sqlalchemy.orm.PropComparator.op(opstring, precedence=0, is_comparison=False, return_type=None)¶

inherited from the Operators.op() method of Operators

生成泛型运算符函数。

例如。：：

somecolumn.op("*")(5)

生产：：

somecolumn * 5

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

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

是中的值的位与 somecolumn .

参数

operator¶ -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。
precedence¶ -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时，较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (, ） AS 运算符。值100将大于或等于所有运算符，-100将小于或等于所有运算符。
is_comparison¶ -- 如果为真，则该运算符将被视为“比较”运算符，即计算为布尔真/假值，如 == ， > 等等。应设置此标志，以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded:：0.9.2-添加了 Operators.op.is_comparison 旗帜。
return_type¶ -- 一 TypeEngine 类或对象，它将强制此运算符生成的表达式的返回类型为该类型。默认情况下，指定 Operators.op.is_comparison 将决心 Boolean ，而那些不属于左侧操作数的类型。

参见

ColumnOperators.regexp_replace()

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

method sqlalchemy.orm.PropComparator.operate(op, *other, **kwargs)¶

inherited from the Operators.operate() method of Operators

对参数进行运算。

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

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

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

参数

op¶ -- 操作员可调用。
*other¶ -- 操作的“另一方”。对于大多数操作，将是单个标量。
**kwargs¶ -- 修饰语。这些可由特殊操作员通过，如 ColumnOperators.contains() .

method sqlalchemy.orm.PropComparator.regexp_match(pattern, flags=None)¶

inherited from the ColumnOperators.regexp_match() method of ColumnOperators

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

例如。：：

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

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

示例包括：

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

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

参数

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

1.4 新版功能.

参见

method sqlalchemy.orm.PropComparator.regexp_replace(pattern, replacement, flags=None)¶

inherited from the ColumnOperators.regexp_replace() method of ColumnOperators

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

例如。：：

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

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

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

参数

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

1.4 新版功能.

参见

ColumnOperators.regexp_match()

method sqlalchemy.orm.PropComparator.reverse_operate(op, other, **kwargs)¶

inherited from the Operators.reverse_operate() method of Operators

对参数进行反向运算。

用法与 operate() .

method sqlalchemy.orm.PropComparator.startswith(other, **kwargs)¶

inherited from the ColumnOperators.startswith() method of ColumnOperators

实施 startswith 操作员。

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

column LIKE <other> || '%'

例如。：：

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

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

参数

other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.startswith.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.startswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，类似于：param |'%'ESCAPE'/'的值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.startswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn-like :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.startswith.autoescape ：：somecolumn.startswith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

class sqlalchemy.orm.RelationshipProperty(argument, secondary=None, primaryjoin=None, secondaryjoin=None, foreign_keys=None, uselist=None, order_by=False, backref=None, back_populates=None, overlaps=None, post_update=False, cascade=False, viewonly=False, lazy='select', collection_class=None, passive_deletes=False, passive_updates=True, remote_side=None, enable_typechecks=True, join_depth=None, comparator_factory=None, single_parent=False, innerjoin=False, distinct_target_key=None, doc=None, active_history=False, cascade_backrefs=True, load_on_pending=False, bake_queries=True, _local_remote_pairs=None, query_class=None, info=None, omit_join=None, sync_backref=None, _legacy_inactive_history_style=False)¶

描述一个对象属性，该属性包含与相关数据库表对应的单个项或项列表。

公共构造函数是 relationship() 功能。

参见

关系配置

类签名

class sqlalchemy.orm.RelationshipProperty (sqlalchemy.orm.StrategizedProperty)

class Comparator(prop, parentmapper, adapt_to_entity=None, of_type=None, extra_criteria=())¶

为生成布尔、比较和其他运算符 RelationshipProperty 属性。

参见文档 PropComparator 有关ORM级运算符定义的简要概述。

参见

类签名

class sqlalchemy.orm.RelationshipProperty.Comparator (sqlalchemy.orm.PropComparator)

method sqlalchemy.orm.RelationshipProperty.Comparator.__eq__(other)¶

实施 == 操作员。

在多对一的上下文中，例如：

MyClass.some_prop == <some object>

这通常会产生一个子句，例如：

mytable.related_id == <some id>

哪里 <some id> 是给定对象的主键。

这个 == 运算符为非多对一比较提供部分功能：

不支持与集合进行比较。使用 Comparator.contains() .
与标量一对多相比，将生成一个子句，将父级中的目标列与给定目标进行比较。
与标量“多对多”相比，关联表的别名也将呈现出来，形成作为查询主体一部分的自然联接。对于超出简单比较和连词的查询（如使用或的查询），这将不起作用。使用显式联接、outerjoin或 Comparator.has() 对于更全面的非多对一标量成员测试。
对比 None 在一对多或多对多上下文中给出，将产生一个不存在子句。

method sqlalchemy.orm.RelationshipProperty.Comparator.__init__(prop, parentmapper, adapt_to_entity=None, of_type=None, extra_criteria=())¶: 建设 Comparator 是ORM属性机制的内部机制。

method sqlalchemy.orm.RelationshipProperty.Comparator.__le__(other)¶

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

实施 <= 操作员。

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

method sqlalchemy.orm.RelationshipProperty.Comparator.__lt__(other)¶

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

实施 < 操作员。

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

method sqlalchemy.orm.RelationshipProperty.Comparator.__ne__(other)¶

实施 != 操作员。

在多对一的上下文中，例如：

MyClass.some_prop != <some object>

这通常会产生一个子句，例如：

mytable.related_id != <some id>

哪里 <some id> 是给定对象的主键。

这个 != 运算符为非多对一比较提供部分功能：

不支持与集合进行比较。使用 Comparator.contains() 与 not_() .
与标量一对多相比，将生成一个子句，将父级中的目标列与给定目标进行比较。
与标量“多对多”相比，关联表的别名也将呈现出来，形成作为查询主体一部分的自然联接。对于超出简单比较和连词的查询（如使用或的查询），这将不起作用。使用显式联接、outerjoin或 Comparator.has() 与 not_() 对于更全面的非多对一标量成员测试。
对比 None 在一对多或多对多上下文中给出，生成一个exists子句。

method sqlalchemy.orm.RelationshipProperty.Comparator.adapt_to_entity(adapt_to_entity)¶: 返回此propComparator的副本，该副本将使用给定的 AliasedInsp 产生相应的表达式。

attribute sqlalchemy.orm.RelationshipProperty.Comparator.adapter¶: inherited from the PropComparator.adapter attribute of PropComparator

生成一个可调用文件，使列表达式适应此比较器的别名版本。

method sqlalchemy.orm.RelationshipProperty.Comparator.all_()¶

inherited from the ColumnOperators.all_() method of ColumnOperators

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

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

注解

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

1.1 新版功能.

method sqlalchemy.orm.RelationshipProperty.Comparator.and_(*other)¶

添加和条件。

见 PropComparator.and_() 举个例子。

1.4 新版功能.

method sqlalchemy.orm.RelationshipProperty.Comparator.any(criterion=None, **kwargs)¶

生成一个表达式，使用exists根据特定条件测试集合。

像这样的表达：

session.query(MyClass).filter(
    MyClass.somereference.any(SomeRelated.x==2)
)

将生成如下查询：

SELECT * FROM my_table WHERE
EXISTS (SELECT 1 FROM related WHERE related.my_id=my_table.id
AND related.x=2)

因为 Comparator.any() 使用关联子查询时，与大型目标表相比，它的性能不如使用联接时好。

Comparator.any() 对于测试空集合特别有用：

session.query(MyClass).filter(
    ~MyClass.somereference.any()
)

将生产：

SELECT * FROM my_table WHERE
NOT (EXISTS (SELECT 1 FROM related WHERE
related.my_id=my_table.id))

Comparator.any() 仅对集合有效，即 relationship() 那有 uselist=True . 对于标量引用，请使用 Comparator.has() .

method sqlalchemy.orm.RelationshipProperty.Comparator.any_()¶

inherited from the ColumnOperators.any_() method of ColumnOperators

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

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

注解

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

1.1 新版功能.

method sqlalchemy.orm.RelationshipProperty.Comparator.asc()¶: inherited from the ColumnOperators.asc() method of ColumnOperators

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

method sqlalchemy.orm.RelationshipProperty.Comparator.between(cleft, cright, symmetric=False)¶: inherited from the ColumnOperators.between() method of ColumnOperators

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

method sqlalchemy.orm.RelationshipProperty.Comparator.bool_op(opstring, precedence=0)¶

inherited from the Operators.bool_op() method of Operators

返回自定义布尔运算符。

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

参见

Operators.op()

method sqlalchemy.orm.RelationshipProperty.Comparator.collate(collation)¶: inherited from the ColumnOperators.collate() method of ColumnOperators

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

参见

collate()

method sqlalchemy.orm.RelationshipProperty.Comparator.concat(other)¶

inherited from the ColumnOperators.concat() method of ColumnOperators

实现“concat”运算符。

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

method sqlalchemy.orm.RelationshipProperty.Comparator.contains(other, **kwargs)¶

返回一个简单表达式，用于测试集合是否包含特定项。

Comparator.contains() 仅对集合有效，即 relationship() 实现一对多或多对多 uselist=True .

在简单的一对多上下文中使用时，表达式如下：

MyClass.contains(other)

生成如下子句：

mytable.id == <some id>

哪里 <some id> 上的外键属性的值 other 它引用其父对象的主键。从这一点可以得出这样的结论 Comparator.contains() 在与简单的一对多操作一起使用时非常有用。

对于多对多的操作， Comparator.contains() 有更多的警告。关联表将在语句中呈现，生成一个“隐式”联接，即在FROM子句中包含多个表，这些表在WHERE子句中相等：

query(MyClass).filter(MyClass.contains(other))

生成如下查询：

SELECT * FROM my_table, my_association_table AS
my_association_table_1 WHERE
my_table.id = my_association_table_1.parent_id
AND my_association_table_1.child_id = <some id>

哪里 <some id> 将是 other 。从上面可以清楚地看出， Comparator.contains() 将要 not 在超越简单和合取的查询中使用多对多集合时，如多对多集合，请使用多对多集合 Comparator.contains() 由OR联接的表达式。在这种情况下，需要使用子查询或显式的“外部联接”。看见 Comparator.any() 有关使用EXISTS的性能较差的替代方案，请参阅 Query.outerjoin() 以及使用联接查询有关构造外部联接的更多详细信息，请参见。

此操作员可能会忽略kwargs，但它是API一致性所必需的。

method sqlalchemy.orm.RelationshipProperty.Comparator.desc()¶: inherited from the ColumnOperators.desc() method of ColumnOperators

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

method sqlalchemy.orm.RelationshipProperty.Comparator.distinct()¶: inherited from the ColumnOperators.distinct() method of ColumnOperators

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

method sqlalchemy.orm.RelationshipProperty.Comparator.endswith(other, **kwargs)¶

inherited from the ColumnOperators.endswith() method of ColumnOperators

实现“endswith”运算符。

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

column LIKE '%' || <other>

例如。：：

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

参数

other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.endswith.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.endswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param ESCAPE“/”值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.endswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param ESCAPE '^' The parameter may also be combined with ColumnOperators.endswith.autoescape ：：someColumn.endsWith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

attribute sqlalchemy.orm.RelationshipProperty.Comparator.entity¶

此引用的目标实体 Comparator .

这不是一个 Mapper 或 AliasedInsp 对象。

这是 relationship() .

method sqlalchemy.orm.RelationshipProperty.Comparator.has(criterion=None, **kwargs)¶

生成一个表达式，使用exists根据特定条件测试标量引用。

像这样的表达：

session.query(MyClass).filter(
    MyClass.somereference.has(SomeRelated.x==2)
)

将生成如下查询：

SELECT * FROM my_table WHERE
EXISTS (SELECT 1 FROM related WHERE
related.id==my_table.related_id AND related.x=2)

因为 Comparator.has() 使用关联子查询时，与大型目标表相比，它的性能不如使用联接时好。

Comparator.has() 仅对标量引用有效，即 relationship() 那有 uselist=False . 对于集合引用，请使用 Comparator.any() .

method sqlalchemy.orm.RelationshipProperty.Comparator.ilike(other, escape=None)¶

inherited from the ColumnOperators.ilike() method of ColumnOperators

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

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

lower(a) LIKE lower(other)

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

a ILIKE other

例如。：：

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

参数

other¶ -- 要比较的表达式
escape¶ -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.ilike（“foo/%bar”，escape=“/”）

参见

ColumnOperators.is_not()

method sqlalchemy.orm.RelationshipProperty.Comparator.in_(other)¶: 生成一个In子句-这不是为实现 relationship() -此时基于属性。

method sqlalchemy.orm.RelationshipProperty.Comparator.is_(other)¶

inherited from the ColumnOperators.is_() method of ColumnOperators

实施 IS 操作员。

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

参见

method sqlalchemy.orm.RelationshipProperty.Comparator.is_distinct_from(other)¶

inherited from the ColumnOperators.is_distinct_from() method of ColumnOperators

实施 IS DISTINCT FROM 操作员。

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

1.1 新版功能.

method sqlalchemy.orm.RelationshipProperty.Comparator.is_not(other)¶

inherited from the ColumnOperators.is_not() method of ColumnOperators

实施 IS NOT 操作员。

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

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

参见

method sqlalchemy.orm.RelationshipProperty.Comparator.is_not_distinct_from(other)¶

inherited from the ColumnOperators.is_not_distinct_from() method of ColumnOperators

实施 IS NOT DISTINCT FROM 操作员。

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

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

1.1 新版功能.

method sqlalchemy.orm.RelationshipProperty.Comparator.isnot(other)¶

inherited from the ColumnOperators.isnot() method of ColumnOperators

实施 IS NOT 操作员。

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

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

参见

method sqlalchemy.orm.RelationshipProperty.Comparator.isnot_distinct_from(other)¶

inherited from the ColumnOperators.isnot_distinct_from() method of ColumnOperators

实施 IS NOT DISTINCT FROM 操作员。

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

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

1.1 新版功能.

method sqlalchemy.orm.RelationshipProperty.Comparator.like(other, escape=None)¶

inherited from the ColumnOperators.like() method of ColumnOperators

实施 like 操作员。

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

a LIKE other

例如。：：

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

参数

other¶ -- 要比较的表达式
escape¶ -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.like（“foo/%bar”，escape=“/”）

参见

attribute sqlalchemy.orm.RelationshipProperty.Comparator.mapper¶

目标 Mapper 由此引用 Comparator .

这是 relationship() .

method sqlalchemy.orm.RelationshipProperty.Comparator.match(other, **kwargs)¶

inherited from the ColumnOperators.match() method of ColumnOperators

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

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

PostgreSQL-呈现 x @@ to_tsquery(y)
MySQL -渲染器 MATCH (x) AGAINST (y IN BOOLEAN MODE)

参见

match -具有附加功能的MySQL特定构造。
Oracle-呈现 CONTAINS(x, y)
其他后端可能提供特殊的实现。
没有任何特殊实现的后端将发出“match”操作符。例如，这与sqlite兼容。

method sqlalchemy.orm.RelationshipProperty.Comparator.not_ilike(other, escape=None)¶

inherited from the ColumnOperators.not_ilike() method of ColumnOperators

实施 NOT ILIKE 操作员。

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

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

参见

method sqlalchemy.orm.RelationshipProperty.Comparator.not_in(other)¶

inherited from the ColumnOperators.not_in() method of ColumnOperators

实施 NOT IN 操作员。

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

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

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

参见

method sqlalchemy.orm.RelationshipProperty.Comparator.not_like(other, escape=None)¶

inherited from the ColumnOperators.not_like() method of ColumnOperators

实施 NOT LIKE 操作员。

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

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

参见

method sqlalchemy.orm.RelationshipProperty.Comparator.notilike(other, escape=None)¶

inherited from the ColumnOperators.notilike() method of ColumnOperators

实施 NOT ILIKE 操作员。

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

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

参见

method sqlalchemy.orm.RelationshipProperty.Comparator.notin_(other)¶

inherited from the ColumnOperators.notin_() method of ColumnOperators

实施 NOT IN 操作员。

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

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

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

参见

method sqlalchemy.orm.RelationshipProperty.Comparator.notlike(other, escape=None)¶

inherited from the ColumnOperators.notlike() method of ColumnOperators

实施 NOT LIKE 操作员。

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

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

参见

method sqlalchemy.orm.RelationshipProperty.Comparator.nulls_first()¶: inherited from the ColumnOperators.nulls_first() method of ColumnOperators

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

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

method sqlalchemy.orm.RelationshipProperty.Comparator.nulls_last()¶: inherited from the ColumnOperators.nulls_last() method of ColumnOperators

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

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

method sqlalchemy.orm.RelationshipProperty.Comparator.nullsfirst()¶: inherited from the ColumnOperators.nullsfirst() method of ColumnOperators

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

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

method sqlalchemy.orm.RelationshipProperty.Comparator.nullslast()¶: inherited from the ColumnOperators.nullslast() method of ColumnOperators

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

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

method sqlalchemy.orm.RelationshipProperty.Comparator.of_type(cls)¶

根据多态子类重新定义此对象。

见 PropComparator.of_type() 举个例子。

method sqlalchemy.orm.RelationshipProperty.Comparator.op(opstring, precedence=0, is_comparison=False, return_type=None)¶

inherited from the Operators.op() method of Operators

生成泛型运算符函数。

例如。：：

somecolumn.op("*")(5)

生产：：

somecolumn * 5

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

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

是中的值的位与 somecolumn .

参数

operator¶ -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。
precedence¶ -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时，较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (, ） AS 运算符。值100将大于或等于所有运算符，-100将小于或等于所有运算符。
is_comparison¶ -- 如果为真，则该运算符将被视为“比较”运算符，即计算为布尔真/假值，如 == ， > 等等。应设置此标志，以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded:：0.9.2-添加了 Operators.op.is_comparison 旗帜。
return_type¶ -- 一 TypeEngine 类或对象，它将强制此运算符生成的表达式的返回类型为该类型。默认情况下，指定 Operators.op.is_comparison 将决心 Boolean ，而那些不属于左侧操作数的类型。

参见

ColumnOperators.regexp_replace()

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

method sqlalchemy.orm.RelationshipProperty.Comparator.operate(op, *other, **kwargs)¶

inherited from the Operators.operate() method of Operators

对参数进行运算。

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

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

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

参数

op¶ -- 操作员可调用。
*other¶ -- 操作的“另一方”。对于大多数操作，将是单个标量。
**kwargs¶ -- 修饰语。这些可由特殊操作员通过，如 ColumnOperators.contains() .

method sqlalchemy.orm.RelationshipProperty.Comparator.regexp_match(pattern, flags=None)¶

inherited from the ColumnOperators.regexp_match() method of ColumnOperators

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

例如。：：

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

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

示例包括：

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

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

参数

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

1.4 新版功能.

参见

method sqlalchemy.orm.RelationshipProperty.Comparator.regexp_replace(pattern, replacement, flags=None)¶

inherited from the ColumnOperators.regexp_replace() method of ColumnOperators

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

例如。：：

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

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

参数

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

1.4 新版功能.

参见

ColumnOperators.regexp_match()

method sqlalchemy.orm.RelationshipProperty.Comparator.reverse_operate(op, other, **kwargs)¶

inherited from the Operators.reverse_operate() method of Operators

对参数进行反向运算。

用法与 operate() .

method sqlalchemy.orm.RelationshipProperty.Comparator.startswith(other, **kwargs)¶

inherited from the ColumnOperators.startswith() method of ColumnOperators

实施 startswith 操作员。

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

column LIKE <other> || '%'

例如。：：

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

参数

other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.startswith.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.startswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，类似于：param |'%'ESCAPE'/'的值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.startswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn-like :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.startswith.autoescape ：：somecolumn.startswith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

Mapper.all_orm_descriptors

method sqlalchemy.orm.RelationshipProperty.__init__(argument, secondary=None, primaryjoin=None, secondaryjoin=None, foreign_keys=None, uselist=None, order_by=False, backref=None, back_populates=None, overlaps=None, post_update=False, cascade=False, viewonly=False, lazy='select', collection_class=None, passive_deletes=False, passive_updates=True, remote_side=None, enable_typechecks=True, join_depth=None, comparator_factory=None, single_parent=False, innerjoin=False, distinct_target_key=None, doc=None, active_history=False, cascade_backrefs=True, load_on_pending=False, bake_queries=True, _local_remote_pairs=None, query_class=None, info=None, omit_join=None, sync_backref=None, _legacy_inactive_history_style=False)¶

构建新的 RelationshipProperty 对象。

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

attribute sqlalchemy.orm.RelationshipProperty.cascade¶

“cascade”属性名称集。

在调用“cascadeu迭代器”方法之前，检查此集合。

集合通常只适用于RelationshipProperty。

method sqlalchemy.orm.RelationshipProperty.cascade_iterator(type_, state, dict_, visited_states, halt_on=None)¶

从这个mapperproperty开始，循环访问与特定“cascade”的给定实例相关的实例。

返回迭代器3元组（实例、映射器、状态）。

请注意，在调用Cascade_迭代器之前，首先检查此MapperProperty上给定类型的“Cascade”集合。

此方法通常只适用于RelationshipProperty。

attribute sqlalchemy.orm.RelationshipProperty.class_attribute¶

inherited from the MapperProperty.class_attribute attribute of MapperProperty

返回与此对应的类绑定描述符 MapperProperty .

这基本上是一个 getattr() 呼叫：

return getattr(self.parent.class_, self.key)

即，如果 MapperProperty 被命名 addresses ，它映射到的类是 User ，此序列是可能的：

>>> from sqlalchemy import inspect
>>> mapper = inspect(User)
>>> addresses_property = mapper.attrs.addresses
>>> addresses_property.class_attribute is User.addresses
True
>>> User.addresses.property is addresses_property
True

method sqlalchemy.orm.RelationshipProperty.create_row_processor(context, query_entity, path, mapper, result, adapter, populators)¶: inherited from the StrategizedProperty.create_row_processor() method of StrategizedProperty

生成行处理函数并附加到给定的填充器列表集。

method sqlalchemy.orm.RelationshipProperty.do_init()¶

执行子类特定的初始化后映射器创建步骤。

这是由 MapperProperty 对象的init（）方法。

attribute sqlalchemy.orm.RelationshipProperty.entity¶: 返回目标映射实体，它是所引用的类或别名类的inspect（）。

attribute sqlalchemy.orm.RelationshipProperty.extension_type = symbol('NOT_EXTENSION')¶: inherited from the InspectionAttr.extension_type attribute of InspectionAttr

扩展类型（如果有）。默认为 NOT_EXTENSION

参见

HYBRID_METHOD

HYBRID_PROPERTY

ASSOCIATION_PROXY

method sqlalchemy.orm.RelationshipProperty.init()¶: inherited from the MapperProperty.init() method of MapperProperty

在创建所有映射器之后调用，以组装映射器之间的关系并执行其他后期映射器创建初始化步骤。

method sqlalchemy.orm.RelationshipProperty.instrument_class(mapper)¶

映射器调用该属性以启动由该映射器属性管理的类属性的检测。

这里的mapperproperty通常会调用attributes模块来设置instructedAttribute。

此步骤是设置InstrumentedAttribute的两个步骤中的第一个步骤，在映射器设置过程的早期调用。

attribute sqlalchemy.orm.RelationshipProperty.mapper¶

返回目标 Mapper 为此 RelationshipProperty .

这是一个懒惰的初始化静态属性。

method sqlalchemy.orm.RelationshipProperty.merge(session, source_state, source_dict, dest_state, dest_dict, load, _recursive, _resolve_conflict_map)¶: 合并此表示的属性 MapperProperty 从源对象到目标对象。

method sqlalchemy.orm.RelationshipProperty.post_instrument_class(mapper)¶

inherited from the StrategizedProperty.post_instrument_class() method of StrategizedProperty

执行init（）完成后需要进行的检测调整。

给定的映射器是调用操作的映射器，在继承方案中，该映射器可能与self.parent不同；但是，映射器将始终至少是self.parent的子映射器。

此方法通常由StrategizedProperty使用，它将其委托给loaderStrategy.init_class_attribute（）以对绑定到类的instructedAttribute执行最终设置。

method sqlalchemy.orm.RelationshipProperty.set_parent(parent, init)¶

inherited from the MapperProperty.set_parent() method of MapperProperty

设置引用此映射器属性的父映射器。

此方法被某些子类重写，以便在第一次知道映射器时执行额外的设置。

method sqlalchemy.orm.RelationshipProperty.setup(context, query_entity, path, adapter, **kwargs)¶

inherited from the StrategizedProperty.setup() method of StrategizedProperty

通过查询调用以构造SQL语句。

与目标映射器关联的每个映射器属性都处理查询上下文引用的语句，并根据需要添加列和/或条件。

class sqlalchemy.orm.SynonymProperty(name, map_column=None, descriptor=None, comparator_factory=None, doc=None, info=None)¶

类签名

class sqlalchemy.orm.SynonymProperty (sqlalchemy.orm.descriptor_props.DescriptorProperty)

method sqlalchemy.orm.SynonymProperty.__init__(name, map_column=None, descriptor=None, comparator_factory=None, doc=None, info=None)¶

构建新的 SynonymProperty 对象。

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

method sqlalchemy.orm.SynonymProperty.cascade_iterator(type_, state, dict_, visited_states, halt_on=None)¶

inherited from the MapperProperty.cascade_iterator() method of MapperProperty

从这个mapperproperty开始，循环访问与特定“cascade”的给定实例相关的实例。

返回迭代器3元组（实例、映射器、状态）。

请注意，在调用Cascade_迭代器之前，首先检查此MapperProperty上给定类型的“Cascade”集合。

此方法通常只适用于RelationshipProperty。

attribute sqlalchemy.orm.SynonymProperty.class_attribute¶

inherited from the MapperProperty.class_attribute attribute of MapperProperty

返回与此对应的类绑定描述符 MapperProperty .

这基本上是一个 getattr() 呼叫：

return getattr(self.parent.class_, self.key)

即，如果 MapperProperty 被命名 addresses ，它映射到的类是 User ，此序列是可能的：

>>> from sqlalchemy import inspect
>>> mapper = inspect(User)
>>> addresses_property = mapper.attrs.addresses
>>> addresses_property.class_attribute is User.addresses
True
>>> User.addresses.property is addresses_property
True

method sqlalchemy.orm.SynonymProperty.create_row_processor(context, query_entity, path, mapper, result, adapter, populators)¶: inherited from the MapperProperty.create_row_processor() method of MapperProperty

生成行处理函数并附加到给定的填充器列表集。

method sqlalchemy.orm.SynonymProperty.do_init()¶

inherited from the MapperProperty.do_init() method of MapperProperty

执行子类特定的初始化后映射器创建步骤。

这是由 MapperProperty 对象的init（）方法。

attribute sqlalchemy.orm.SynonymProperty.extension_type = symbol('NOT_EXTENSION')¶: inherited from the InspectionAttr.extension_type attribute of InspectionAttr

扩展类型（如果有）。默认为 NOT_EXTENSION

参见

HYBRID_METHOD

HYBRID_PROPERTY

ASSOCIATION_PROXY

method sqlalchemy.orm.SynonymProperty.init()¶: inherited from the MapperProperty.init() method of MapperProperty

在创建所有映射器之后调用，以组装映射器之间的关系并执行其他后期映射器创建初始化步骤。

method sqlalchemy.orm.SynonymProperty.instrument_class(mapper)¶

inherited from the DescriptorProperty.instrument_class() method of DescriptorProperty

映射器调用该属性以启动由该映射器属性管理的类属性的检测。

这里的mapperproperty通常会调用attributes模块来设置instructedAttribute。

此步骤是设置InstrumentedAttribute的两个步骤中的第一个步骤，在映射器设置过程的早期调用。

method sqlalchemy.orm.SynonymProperty.merge(session, source_state, source_dict, dest_state, dest_dict, load, _recursive, _resolve_conflict_map)¶: inherited from the MapperProperty.merge() method of MapperProperty

合并此表示的属性 MapperProperty 从源对象到目标对象。

method sqlalchemy.orm.SynonymProperty.post_instrument_class(mapper)¶

inherited from the MapperProperty.post_instrument_class() method of MapperProperty

执行init（）完成后需要进行的检测调整。

给定的映射器是调用操作的映射器，在继承方案中，该映射器可能与self.parent不同；但是，映射器将始终至少是self.parent的子映射器。

此方法通常由StrategizedProperty使用，它将其委托给loaderStrategy.init_class_attribute（）以对绑定到类的instructedAttribute执行最终设置。

method sqlalchemy.orm.SynonymProperty.set_parent(parent, init)¶

设置引用此映射器属性的父映射器。

此方法被某些子类重写，以便在第一次知道映射器时执行额外的设置。

method sqlalchemy.orm.SynonymProperty.setup(context, query_entity, path, adapter, **kwargs)¶

inherited from the MapperProperty.setup() method of MapperProperty

通过查询调用以构造SQL语句。

与目标映射器关联的每个映射器属性都处理查询上下文引用的语句，并根据需要添加列和/或条件。

attribute sqlalchemy.orm.SynonymProperty.uses_objects¶

class sqlalchemy.orm.QueryContext(compile_state, statement, params, session, load_options, execution_options=None, bind_arguments=None)¶

class default_load_options(**kw)¶: 类签名

class sqlalchemy.orm.QueryContext.default_load_options (sqlalchemy.sql.expression.Options)

class sqlalchemy.orm.QueryableAttribute(class_, key, parententity, impl=None, comparator=None, of_type=None, extra_criteria=())¶

基类 descriptor 代表 MapperProperty 对象。实际 MapperProperty 可通过 QueryableAttribute.property 属性。

参见

InstrumentedAttribute

MapperProperty

Mapper.attrs

类签名

class sqlalchemy.orm.QueryableAttribute (sqlalchemy.orm.base._MappedAttribute, sqlalchemy.orm.base.InspectionAttr, sqlalchemy.orm.PropComparator, sqlalchemy.sql.traversals.HasCopyInternals, sqlalchemy.sql.roles.JoinTargetRole, sqlalchemy.sql.roles.OnClauseRole, sqlalchemy.sql.expression.Immutable, sqlalchemy.sql.traversals.MemoizedHasCacheKey)

method sqlalchemy.orm.QueryableAttribute.__eq__(other)¶

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

实施 == 操作员。

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

method sqlalchemy.orm.QueryableAttribute.__le__(other)¶

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

实施 <= 操作员。

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

method sqlalchemy.orm.QueryableAttribute.__lt__(other)¶

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

实施 < 操作员。

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

method sqlalchemy.orm.QueryableAttribute.__ne__(other)¶

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

实施 != 操作员。

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

method sqlalchemy.orm.QueryableAttribute.adapt_to_entity(adapt_to_entity)¶: 返回此propComparator的副本，该副本将使用给定的 AliasedInsp 产生相应的表达式。

attribute sqlalchemy.orm.QueryableAttribute.adapter¶: inherited from the PropComparator.adapter attribute of PropComparator

生成一个可调用文件，使列表达式适应此比较器的别名版本。

method sqlalchemy.orm.QueryableAttribute.all_()¶

inherited from the ColumnOperators.all_() method of ColumnOperators

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

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

注解

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

1.1 新版功能.

method sqlalchemy.orm.QueryableAttribute.and_(*other)¶

向由此关系属性表示的ON子句添加其他条件。

例如。：：

stmt = select(User).join(
    User.addresses.and_(Address.email_address != 'foo')
)

stmt = select(User).options(
    joinedload(User.addresses.and_(Address.email_address != 'foo'))
)

1.4 新版功能.

参见

扩充内置ON子句

向加载程序选项添加条件

with_loader_criteria()

method sqlalchemy.orm.QueryableAttribute.any(criterion=None, **kwargs)¶

inherited from the PropComparator.any() method of PropComparator

如果此集合包含符合给定条件的任何成员，则返回true。

通常执行 any() 是 Comparator.any() .

参数

criterion¶ -- 针对成员类的表或属性制定的可选子句。
**kwargs¶ -- 对应于成员类属性名的键/值对，将通过相等于相应的值进行比较。

method sqlalchemy.orm.QueryableAttribute.any_()¶

inherited from the ColumnOperators.any_() method of ColumnOperators

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

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

注解

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

1.1 新版功能.

method sqlalchemy.orm.QueryableAttribute.asc()¶: inherited from the ColumnOperators.asc() method of ColumnOperators

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

method sqlalchemy.orm.QueryableAttribute.between(cleft, cright, symmetric=False)¶: inherited from the ColumnOperators.between() method of ColumnOperators

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

method sqlalchemy.orm.QueryableAttribute.bool_op(opstring, precedence=0)¶

inherited from the Operators.bool_op() method of Operators

返回自定义布尔运算符。

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

参见

Operators.op()

method sqlalchemy.orm.QueryableAttribute.collate(collation)¶: inherited from the ColumnOperators.collate() method of ColumnOperators

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

参见

collate()

method sqlalchemy.orm.QueryableAttribute.concat(other)¶

inherited from the ColumnOperators.concat() method of ColumnOperators

实现“concat”运算符。

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

method sqlalchemy.orm.QueryableAttribute.contains(other, **kwargs)¶

inherited from the ColumnOperators.contains() method of ColumnOperators

实现“contains”运算符。

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

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

例如。：：

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

参数

other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.contains.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.包含（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param |‘%‘ESCAPE’/”，值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.contains（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.contains.autoescape ：：someColumn.contains（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

method sqlalchemy.orm.QueryableAttribute.desc()¶: inherited from the ColumnOperators.desc() method of ColumnOperators

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

method sqlalchemy.orm.QueryableAttribute.distinct()¶: inherited from the ColumnOperators.distinct() method of ColumnOperators

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

method sqlalchemy.orm.QueryableAttribute.endswith(other, **kwargs)¶

inherited from the ColumnOperators.endswith() method of ColumnOperators

实现“endswith”运算符。

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

column LIKE '%' || <other>

例如。：：

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

参数

other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.endswith.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.endswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param ESCAPE“/”值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.endswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param ESCAPE '^' The parameter may also be combined with ColumnOperators.endswith.autoescape ：：someColumn.endsWith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

attribute sqlalchemy.orm.QueryableAttribute.expression¶

由此表示的SQL表达式对象 QueryableAttribute 。

这通常是 ColumnElement 表示列表达式的子类。

attribute sqlalchemy.orm.QueryableAttribute.extension_type = symbol('NOT_EXTENSION')¶: inherited from the InspectionAttr.extension_type attribute of InspectionAttr

扩展类型（如果有）。默认为 NOT_EXTENSION

参见

HYBRID_METHOD

HYBRID_PROPERTY

ASSOCIATION_PROXY

method sqlalchemy.orm.QueryableAttribute.has(criterion=None, **kwargs)¶

inherited from the PropComparator.has() method of PropComparator

如果此元素引用满足给定条件的成员，则返回true。

通常执行 has() 是 Comparator.has() .

参数

criterion¶ -- 针对成员类的表或属性制定的可选子句。
**kwargs¶ -- 对应于成员类属性名的键/值对，将通过相等于相应的值进行比较。

method sqlalchemy.orm.QueryableAttribute.ilike(other, escape=None)¶

inherited from the ColumnOperators.ilike() method of ColumnOperators

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

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

lower(a) LIKE lower(other)

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

a ILIKE other

例如。：：

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

参数

other¶ -- 要比较的表达式
escape¶ -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.ilike（“foo/%bar”，escape=“/”）

参见

ColumnOperators.is_not()

method sqlalchemy.orm.QueryableAttribute.in_(other)¶

inherited from the ColumnOperators.in_() method of ColumnOperators

实施 in 操作员。

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

给定参数 other 可能是：

文字值列表，例如：
```
stmt.where(column.in_([1, 2, 3]))
```
在此调用表单中，项目列表将转换为一组与给定列表长度相同的绑定参数：
```
WHERE COL IN (?, ?, ?)
```

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

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

空列表，例如：
```
stmt.where(column.in_([]))
```
在此调用形式中，表达式呈现“空集”表达式。这些表达式是针对各个后端量身定做的，通常会尝试将空的SELECT语句作为子查询。例如在SQLite上，表达式为：：
```
WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
在 1.4 版更改: 空IN表达式现在在所有情况下都使用生成的SELECT子查询的执行时间。
绑定参数，例如 bindparam() ，如果包含 bindparam.expanding 旗帜：
```
stmt.where(column.in_(bindparam('value', expanding=True)))
```
在此调用表单中，表达式呈现一个特殊的非SQL占位符表达式，其外观如下：
```
WHERE COL IN ([EXPANDING_value])
```
此占位符表达式在语句执行时被截取，以便转换为前面所示的绑定参数表单的变量号。如果语句的执行方式为：
```
connection.execute(stmt, {"value": [1, 2, 3]})
```
将为数据库传递每个值的绑定参数：
```
WHERE COL IN (?, ?, ?)
```
1.2 新版功能: 添加了“扩展”绑定参数

如果传递空列表，将呈现一个特定于正在使用的数据库的特殊“空列表”表达式。在sqlite上：
```
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
1.3 新版功能: “expanding”绑定参数现在支持空列表

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

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

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

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

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

attribute sqlalchemy.orm.QueryableAttribute.info¶

返回基础SQL元素的“info”字典。

这里的行为如下：

如果属性是列映射属性，即 ColumnProperty ，直接映射到架构级别 Column 对象，此属性将返回 SchemaItem.info 与核心级别相关联的字典 Column 对象。
如果属性是 ColumnProperty 但映射到除 Column ，该属性将引用 MapperProperty.info 与直接关联的字典 ColumnProperty ，假定SQL表达式本身没有自己的 .info 属性（应该是这种情况，除非用户定义的SQL构造已经定义了属性）。
如果属性引用任何其他类型的 MapperProperty 包括 RelationshipProperty ，该属性将引用 MapperProperty.info 与之相关联的词典 MapperProperty .
访问 MapperProperty.info 字典 MapperProperty 无条件，包括 ColumnProperty 这与 Column ，可以使用 QueryableAttribute.property 属性为 MyClass.someattribute.property.info .

参见

SchemaItem.info

MapperProperty.info

method sqlalchemy.orm.QueryableAttribute.is_(other)¶

inherited from the ColumnOperators.is_() method of ColumnOperators

实施 IS 操作员。

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

参见

method sqlalchemy.orm.QueryableAttribute.is_distinct_from(other)¶

inherited from the ColumnOperators.is_distinct_from() method of ColumnOperators

实施 IS DISTINCT FROM 操作员。

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

1.1 新版功能.

method sqlalchemy.orm.QueryableAttribute.is_not(other)¶

inherited from the ColumnOperators.is_not() method of ColumnOperators

实施 IS NOT 操作员。

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

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

参见

method sqlalchemy.orm.QueryableAttribute.is_not_distinct_from(other)¶

inherited from the ColumnOperators.is_not_distinct_from() method of ColumnOperators

实施 IS NOT DISTINCT FROM 操作员。

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

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

1.1 新版功能.

method sqlalchemy.orm.QueryableAttribute.isnot(other)¶

inherited from the ColumnOperators.isnot() method of ColumnOperators

实施 IS NOT 操作员。

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

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

参见

method sqlalchemy.orm.QueryableAttribute.isnot_distinct_from(other)¶

inherited from the ColumnOperators.isnot_distinct_from() method of ColumnOperators

实施 IS NOT DISTINCT FROM 操作员。

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

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

1.1 新版功能.

method sqlalchemy.orm.QueryableAttribute.like(other, escape=None)¶

inherited from the ColumnOperators.like() method of ColumnOperators

实施 like 操作员。

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

a LIKE other

例如。：：

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

参数

other¶ -- 要比较的表达式
escape¶ -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.like（“foo/%bar”，escape=“/”）

参见

method sqlalchemy.orm.QueryableAttribute.match(other, **kwargs)¶

inherited from the ColumnOperators.match() method of ColumnOperators

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

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

PostgreSQL-呈现 x @@ to_tsquery(y)
MySQL -渲染器 MATCH (x) AGAINST (y IN BOOLEAN MODE)

参见

match -具有附加功能的MySQL特定构造。
Oracle-呈现 CONTAINS(x, y)
其他后端可能提供特殊的实现。
没有任何特殊实现的后端将发出“match”操作符。例如，这与sqlite兼容。

class memoized_attribute(fget, doc=None)¶: 只读@属性，只计算一次。

method sqlalchemy.orm.QueryableAttribute.classmethod memoized_instancemethod(fn)¶: inherited from the HasMemoized.memoized_instancemethod() method of HasMemoized

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

method sqlalchemy.orm.QueryableAttribute.not_ilike(other, escape=None)¶

inherited from the ColumnOperators.not_ilike() method of ColumnOperators

实施 NOT ILIKE 操作员。

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

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

参见

method sqlalchemy.orm.QueryableAttribute.not_in(other)¶

inherited from the ColumnOperators.not_in() method of ColumnOperators

实施 NOT IN 操作员。

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

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

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

参见

method sqlalchemy.orm.QueryableAttribute.not_like(other, escape=None)¶

inherited from the ColumnOperators.not_like() method of ColumnOperators

实施 NOT LIKE 操作员。

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

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

参见

method sqlalchemy.orm.QueryableAttribute.notilike(other, escape=None)¶

inherited from the ColumnOperators.notilike() method of ColumnOperators

实施 NOT ILIKE 操作员。

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

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

参见

method sqlalchemy.orm.QueryableAttribute.notin_(other)¶

inherited from the ColumnOperators.notin_() method of ColumnOperators

实施 NOT IN 操作员。

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

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

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

参见

method sqlalchemy.orm.QueryableAttribute.notlike(other, escape=None)¶

inherited from the ColumnOperators.notlike() method of ColumnOperators

实施 NOT LIKE 操作员。

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

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

参见

method sqlalchemy.orm.QueryableAttribute.nulls_first()¶: inherited from the ColumnOperators.nulls_first() method of ColumnOperators

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

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

method sqlalchemy.orm.QueryableAttribute.nulls_last()¶: inherited from the ColumnOperators.nulls_last() method of ColumnOperators

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

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

method sqlalchemy.orm.QueryableAttribute.nullsfirst()¶: inherited from the ColumnOperators.nullsfirst() method of ColumnOperators

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

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

method sqlalchemy.orm.QueryableAttribute.nullslast()¶: inherited from the ColumnOperators.nullslast() method of ColumnOperators

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

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

method sqlalchemy.orm.QueryableAttribute.of_type(entity)¶

根据多态子类重新定义这个对象， with_polymorphic() 构造，或 aliased() 构造。

返回一个新的PropComparator，从中可以计算出进一步的条件。

例如。：：

query.join(Company.employees.of_type(Engineer)).\
   filter(Engineer.name=='foo')

参数: class_¶ -- 一个类或映射器，指示条件将针对这个特定的子类。

参见

在关系中引用特定的子类型

method sqlalchemy.orm.QueryableAttribute.op(opstring, precedence=0, is_comparison=False, return_type=None)¶

inherited from the Operators.op() method of Operators

生成泛型运算符函数。

例如。：：

somecolumn.op("*")(5)

生产：：

somecolumn * 5

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

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

是中的值的位与 somecolumn .

参数

operator¶ -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。
precedence¶ -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时，较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (, ） AS 运算符。值100将大于或等于所有运算符，-100将小于或等于所有运算符。
is_comparison¶ -- 如果为真，则该运算符将被视为“比较”运算符，即计算为布尔真/假值，如 == ， > 等等。应设置此标志，以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded:：0.9.2-添加了 Operators.op.is_comparison 旗帜。
return_type¶ -- 一 TypeEngine 类或对象，它将强制此运算符生成的表达式的返回类型为该类型。默认情况下，指定 Operators.op.is_comparison 将决心 Boolean ，而那些不属于左侧操作数的类型。

参见

ColumnOperators.regexp_replace()

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

method sqlalchemy.orm.QueryableAttribute.operate(op, *other, **kwargs)¶

对参数进行运算。

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

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

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

参数

op¶ -- 操作员可调用。
*other¶ -- 操作的“另一方”。对于大多数操作，将是单个标量。
**kwargs¶ -- 修饰语。这些可由特殊操作员通过，如 ColumnOperators.contains() .

attribute sqlalchemy.orm.QueryableAttribute.parent¶

返回表示父级的检查实例。

这将是 Mapper 或 AliasedInsp ，取决于与此属性关联的父实体的性质。

attribute sqlalchemy.orm.QueryableAttribute.property¶

返回 MapperProperty 与此关联 QueryableAttribute .

这里的返回值通常是 ColumnProperty 或 RelationshipProperty .

method sqlalchemy.orm.QueryableAttribute.regexp_match(pattern, flags=None)¶

inherited from the ColumnOperators.regexp_match() method of ColumnOperators

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

例如。：：

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

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

示例包括：

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

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

参数

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

1.4 新版功能.

参见

method sqlalchemy.orm.QueryableAttribute.regexp_replace(pattern, replacement, flags=None)¶

inherited from the ColumnOperators.regexp_replace() method of ColumnOperators

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

例如。：：

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

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

参数

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

1.4 新版功能.

参见

ColumnOperators.regexp_match()

method sqlalchemy.orm.QueryableAttribute.reverse_operate(op, other, **kwargs)¶

对参数进行反向运算。

用法与 operate() .

method sqlalchemy.orm.QueryableAttribute.startswith(other, **kwargs)¶

inherited from the ColumnOperators.startswith() method of ColumnOperators

实施 startswith 操作员。

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

column LIKE <other> || '%'

例如。：：

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

参数

other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.startswith.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.startswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，类似于：param |'%'ESCAPE'/'的值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.startswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn-like :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.startswith.autoescape ：：somecolumn.startswith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见