关系 API

对象名称	描述
backref（名称， **kwargs）	使用 relationship.backref 参数时， 提供了在新建 relationship（） 生成。
dynamic_loader（[参数]， **kw）	构造动态加载的 mapper 属性。
外国 （expr）	使用 'foreign' 注释注释 primaryjoin 表达式的一部分。
relationship（[argument， secondary]， *， [uselist， collection_class， primaryjoin， secondaryjoin， back_populates， order_by， backref， overlaps， post_update， cascade， viewonly， init， repr， default， default_factory， compare， kw_only， hash， lazy， passive_deletes， passive_updates， active_history， enable_typechecks， foreign_keys， remote_side， join_depth， comparator_factory， single_parent， innerjoin， distinct_target_key， load_on_pending， query_class， info， omit_join， sync_backref]， **kw）	提供两个映射类之间的关系。
远程 （expr）	使用 'remote' 注释注释 primaryjoin 表达式的一部分。

函数 sqlalchemy.orm 中。relationship（argument：_RelationshipArgumentType[Any]None=无， secondary：_RelationshipSecondaryArgumentNone=None， *， uselist：boolNone=None， collection_class：Type[Collection[Any]]Callable[[]，Collection[Any]]None=None， primaryjoin：_RelationshipJoinConditionArgumentNone=None， secondaryjoin：_RelationshipJoinConditionArgumentNone=None， back_populates：strNone=None， order_by： _ORMOrderByArgument = False， backref：ORMBackrefArgumentNone=None， overlaps：strNone=None， post_update： bool = False， cascade： str = 'save-update， merge'， viewonly： bool = False， init：_NoArgbool=_NoArg.NO_ARG， repr：_NoArgbool=_NoArg.NO_ARG， default：_NoArg_T=_NoArg.NO_ARG， default_factory：_NoArgCallable[[]，_T]=_NoArg.NO_ARG， 比较：_NoArgbool=_NoArg.NO_ARG， kw_only：_NoArgbool=_NoArg.NO_ARG， hash：_NoArgboolNone=_NoArg.NO_ARG， 懒惰： _LazyLoadArgumentType = 'select'， passive_deletes：Literal['all']bool=False， passive_updates： bool = True， active_history： bool = False， enable_typechecks： bool = True， foreign_keys：_ORMColCollectionArgumentNone=无， remote_side：_ORMColCollectionArgumentNone=无， join_depth：intNone=无， comparator_factory：Type[RelationshipProperty.Comparator[Any]]None=无， single_parent： bool = False， innerjoin： bool = False， distinct_target_key：boolNone=None， load_on_pending： bool = False， query_class：Type[Query[Any]]None=None， info：_InfoTypeNone=None， omit_join： Literal[None， False] = 无， sync_backref：boolNone=无， **kw： Any）→ _RelationshipDeclared[Any]

提供两个映射类之间的关系。

这对应于父子或关联表关系。构造的类是 Relationship 的实例。

另请参阅

使用 ORM 相关对象 - SQLAlchemy Unified 教程中的 relationship（） 教程简介

关系配置 - 叙述性文档

参数

• 
  参数 –

  
  此参数引用要关联的类。它接受多种形式，包括对目标类本身的直接引用、目标类的 Mapper 实例、在调用时将返回对类或 Mapper 的引用的 Python 可调用对象/lambda，以及最后的字符串 name 的 API 中，该类将从 registry 来定位类，例如：

  class SomeClass(Base):
      # ...
  
      related = relationship("RelatedClass")

  
  relationship.argument 也可以从 relationship（） 结构，而是放置在左侧的 Mapped 注释中，如果关系应为集合，则应包含 Python 集合类型，例如：

  class SomeClass(Base):
      # ...
  
      related_items: Mapped[List["RelatedItem"]] = relationship()

  
  或者对于多对一或一对一关系：

  class SomeClass(Base):
      # ...
  
      related_item: Mapped["RelatedItem"] = relationship()

  
  另请参阅

  
  使用 Declare 定义映射属性 - 有关使用 Declare 时关系配置的更多详细信息。

• 
  辅助 –

  
  对于多对多关系，指定中间表，通常是 Table 的实例。在不太常见的情况下，参数也可以指定为 Alias 结构，甚至是 Join 构造。

  
  relationship.secondary 也可以作为可调用函数传递，该函数在 Mapper 初始化时进行评估。当使用 Declare 时，它也可以是一个字符串参数，用于记录 Table 的名称 那是 存在于 MetaData 中 与 parent-mapped Table 的 table 中。

  
  警告

  
  当作为 Python 可评估字符串传递时，将使用 Python 的 eval（） 函数解释参数。 不要将不受信任的输入传递给此字符串。有关 relationship（） 参数的声明性评估的详细信息，请参阅关系参数的评估。

  
  relationship.secondary 关键字参数是 通常适用于中介 桌子 不会在任何直接类映射中以其他方式表示。如果 “secondary” table 也被显式映射到其他位置（例如，如 Association 对象），则应考虑应用 relationship.viewonly 标志，以便此 关系（） 不用于持久性作，这些作 可能与 Association Object 模式的 THE SET 冲突。

  
  另请参阅

  
  多对多 - “多对多”的参考示例。

  
  自引用多对多关系 - 在自引用情况下使用多对多的具体内容。

  
  配置多对多关系 - 使用声明性时的其他选项。

  
  Association Object - 替代 relationship.secondary 组合关联时 table 关系，允许其他属性 在 association 表上指定。

  
  复合 “Secondary” Joins - 一种较少使用的模式，在某些情况下可以启用复杂的 relationship（） SQL 条件。

• 
  active_history=False – 当 True 时，表示 多对一引用在替换时应加载，如果 尚未加载。通常，用于 简单的 many-to-one 只需要知道 “new” 值来执行刷新。此标志可用 对于使用 get_history（） 还需要知道属性的 “previous” 值。

• 
  反向引用 –

  
  对字符串关系名称或 backref（） 的引用 构造，该构造将用于自动生成新的 relationship（） 的 URL，然后使用双向relationship.back_populates 配置。

  
  在现代 Python 中，显式使用 relationship（） 使用 relationship.back_populates 应该是首选，因为它在 Mapper 配置方面更健壮，并且在概念上也更简单。它还集成了 SQLAlchemy 2.0 中引入的新 PEP 484 类型功能，这是动态生成的属性无法实现的。

  
  另请参阅

  
  使用旧版 'backref' 关系参数 - 使用说明 relationship.backref 的

  
  使用 ORM 相关对象 - 在 SQLAlchemy Unified Tutorial 中，概述了使用 relationship.back_populates 的双向关系配置和行为

  
  backref（） - 允许控制 relationship（） 配置。

• back_populates –

  
  指示将与此类同步的相关类上的 relationship（） 的名称。通常期望相关类上的 relationship（） 也引用这个类。这允许每个 relationship（） 两侧的对象同步 Python 中的状态更改，并为工作单元提供指令 flush 过程 持久化。

  
  另请参阅

  
  使用 ORM 相关对象 - 在 SQLAlchemy Unified Tutorial 中，概述了双向关系配置和行为。

  
  基本关系模式 - 包括许多示例 relationship.back_populates。

  
  relationship.backref - 遗留表单，允许更简洁的配置，但不支持显式键入

• 
  重叠 –

  
  此映射器、后代映射器或目标映射器上其他关系的字符串名称或逗号分隔的名称集，此关系可以在持久性时写入相同的外键。这样做的唯一效果是消除此关系在持久化时将与另一个关系冲突的警告。这用于在写入时确实能够相互冲突的此类关系，但应用程序将确保不会发生此类冲突。

  
  在 1.4 版本加入.

  
  另请参阅

  
  关系 X 会将列 Q 复制到列 P，这与关系冲突：“Y”- 用法示例

• 
  级联 –

  
  以逗号分隔的级联规则列表，用于确定 Session作应如何从父级联到子级联。默认为 False，这意味着应使用默认级联 - 此默认级联为 “save-update， merge”。

  
  可用的级联包括 save-update、merge 和 expunge、delete、delete-orphan 和 refresh-expire。附加选项 all 表示 "save-update, merge, refresh-expire, expunge, delete" ，通常用作 “all， delete-orphan” 来指示相关对象应与 parent 对象，并在取消关联时删除。

  
  另请参阅

  
  Cascades （级联） - 有关每个可用级联选项的完整详细信息。

• 
  cascade_backrefs=错误 –

  
  遗产;此标志始终为 False。

  
  在 2.0 版本发生变更： “cascade_backrefs” 功能已被删除。

• collection_class –

  
  返回新的列表保存对象的类或可调用对象。将代替用于存储元素的普通列表。

  
  另请参阅

  
  自定义集合访问 - 介绍性文档和示例。

• comparator_factory –

  
  扩展 Comparator 的类 它提供自定义 SQL 子句生成以进行比较 操作。

  
  另请参阅

  
  PropComparator - 有关在此级别重新定义比较器的一些详细信息。

  
  作员自定义 - 此功能的简要介绍。

• 
  distinct_target_key=无 –

  
  指示 “subquery” 预先加载是否应将 DISTINCT 关键字应用于最内层的 SELECT 语句。当保留为 None 时，当目标列不包含目标表的完整主键时，将应用 DISTINCT 关键字。当设置为 True 时，DISTINCT 关键字将无条件地应用于最内层的 SELECT。

  
  当 DISTINCT 将最内层子查询的性能降低到超过最内层行可能导致的重复性能时，可能需要将此标志设置为 False。

  
  另请参阅

  
  关系加载技术 - 包括子查询预先加载的简介。

• 
  doc – 将应用于结果描述符的文档字符串。

• foreign_keys –

  
  在此关系的上下文中，将用作 “外键” 列的列列表，或引用远程列中值的列 （） 对象的 relationship.primaryJoin 条件。也就是说，如果 relationship.primaryjoin 此 relationship（） 的条件是 a.id == b.a_id，并且 b.a_id 中的值必须出现在 a.id 中，那么此 relationship（） b.a_id。

  
  在正常情况下，relationship.foreign_keys parameter 不是必需的。relationship（） 将 自动确定 relationship.primaryjoin 条件为 根据这些 指定 ForeignKey、 或作为引用列在 ForeignKeyConstraint 结构。 仅在以下情况下需要 relationship.foreign_keys：

  1. 
     有多种方法可以构造从本地表到远程表的连接，因为存在多个外键引用。设置 foreign_keys 将限制 关系（） 仅考虑指定 这里显示为 “foreign”。

  2. 
     被映射的 Table 实际上没有 ForeignKey 或 ForeignKeyConstraint 的 构造存在，通常是因为表 从不支持外键的数据库中反映 反射 （MySQL MyISAM） 中。

  3. 
     relationship.primaryjoin 参数用于 构造一个非标准的 join 条件，该条件使用 列或表达式通常不引用其 “parent” 列，例如由 使用 SQL 函数进行复杂比较。

  
  relationship（） 结构将引发 informative 建议使用 relationship.foreign_keys 参数。在典型情况下，如果 relationship（） 没有引发任何异常，则 通常不需要relationship.foreign_keys参数。

  
  relationship.foreign_keys也可以作为可调用函数传递，该函数在 mapper 初始化时进行评估，并且可以在使用 Declare 时作为 Python 可评估字符串传递。

  
  警告

  
  当作为 Python 可评估字符串传递时，将使用 Python 的 eval（） 函数解释参数。 不要将不受信任的输入传递给此字符串。有关 relationship（） 参数的声明性评估的详细信息，请参阅关系参数的评估。

  
  另请参阅

  
  处理多个连接路径

  
  创建自定义外部条件

  
  foreign（） - 允许直接注释 relationship.primaryjoin 中的 “foreign” 列 条件。

• 
  info– 可选的数据字典，将被填充到 MapperProperty.info 对象的属性。

• innerjoin=False –

  
  当 True 时，联接的预先加载将使用内部联接来联接相关表，而不是外部联接。此选项的目的通常是性能方面的一个，因为内部联接通常比外部联接性能更好。

  
  当关系使用不可为 null 的本地外键通过多对一引用对象时，或者当引用是一对一引用或保证具有一个或至少一个条目的集合时，可以将此标志设置为 True。

  
  该选项支持与 joinedload.innerjoin 相同的 “nested” 和 “unnested” 选项。有关嵌套/非嵌套行为的详细信息，请参阅该标志。

  
  另请参阅

  
  joinedload.innerjoin - 由 loader 选项指定的选项，包括有关嵌套行为的详细信息。

  
  使用哪种负载 ？- 讨论了各种加载程序选项的一些细节。

• join_depth –

  
  当非 None时，一个整数值，指示 “eager” loaders 应该在自引用或循环关系上加入多少层深度。该数字计算同一 Mapper 在特定 join 分支的加载条件中出现的次数。当保留为默认值 None 时，当 Eager 加载器遇到已经在链中较高位置的相同目标映射器时，它们将停止链接。此选项适用于 joined- 和 subquery- eager loader。

  
  另请参阅

  
  配置自引用预先加载 - 介绍性文档和示例。

• lazy='select' –

  
  指定 应如何加载相关项。 默认值为 select 的值包括：

  • 
    select - 首次访问属性时，应使用单独的 SELECT 语句或身份映射获取进行简单的多对一引用时延迟加载项目。

  • 
    immediate - 项目应该在加载父项时加载，使用单独的 SELECT 语句，或者为简单的多对一引用获取身份映射。

  • 
    joined - 项目应该在与 父级的 JOIN 或 LEFT OUTER JOIN。 是否 联接是否为 “Outer” 由 relationship.innerjoin 参数。

  • 
    subquery - 在加载父项时，应使用一个额外的 SQL 语句“预先”加载项，该语句针对请求的每个集合向原始语句的子查询发出 JOIN。

  • 
    selectin - 在加载父项时，应使用一个或多个附加 SQL 语句“急切地”加载项，这些语句向直接父对象发出 JOIN，并使用 IN 子句指定主键标识符。

  • 
    noload - 任何时候都不应进行加载。相关集合将保持为空。不建议将 noload 策略用于一般用途。有关通用的“从不加载”方法，请参见Write Only Relationships

  • 
    raise - 不允许延迟加载;如果尚未通过 Eager Loading 加载其值，则访问该属性将引发 InvalidRequestError。当对象在加载后要从其附加的 Session 中分离时，可以使用此策略。

  • 
    raise_on_sql - 不允许发出 SQL 的延迟加载; 访问属性（如果其值尚未通过 eager loading 时，将引发一个 InvalidRequestError，如果延迟加载 需要发出 SQL。如果延迟加载可以从身份映射中提取相关值或确定它应为 None，则会加载该值。当对象将与附加的 Session 保持关联时，可以使用此策略，但应阻止其他 SELECT 语句。

  • 
    write_only - 属性将配置一个特殊的 “虚拟收藏”可能会收到 WriteOnlyCollection.add（） 和 WriteOnlyCollection.remove（） 命令来添加或删除单个对象，但在任何情况下都不会直接从数据库加载或迭代完整的对象集。相反，诸如 WriteOnlyCollection.select（）、 WriteOnlyCollection.insert（）中， WriteOnlyCollection.update（） 和 提供了 WriteOnlyCollection.delete（） ，它生成可用于批量加载和修改行的 SQL 构造。用于永远不适合一次加载到内存中的大型集合。

    
    当 write_only Loader 在 左侧。 请参阅该部分 仅写入关系 （Write Only Relationships） 示例。

    
    2.0 版的新Function。

    
    另请参阅

    
    Write Only Relationships - 在 ORM Querying Guide 中

  • 
    dynamic - 该属性将返回预配置的 Query 对象，在迭代结果之前，可以对其应用进一步的筛选作。

    
    当在 左侧。 请参阅该部分 例如，Dynamic Relationship Loaders。

    
    旧版功能

    
    “动态” 惰性加载器策略是 现在 “write_only” 策略是什么，本节中描述的 仅写入关系。

    
    另请参阅

    
    动态关系加载器 - 在 ORM 查询指南

    
    Write Only Relationships - 对于不应完全加载到内存中的大型集合，更普遍有用的方法

  • 
    True - “select”的同义词

  • 
    False - “joined”的同义词

  • 
    None - “noload”的同义词

  
  另请参阅

  
  关系加载技术 - ORM Querying Guide 中有关关系加载器配置的完整文档。

• 
  load_on_pending=错误 –

  
  指示临时或待处理父对象的加载行为。

  
  当设置为 True 时，会导致 lazy-loader 对非持久父对象发出查询，这意味着它从未被刷新。当禁用 autoflush 时，这可能会对待处理对象生效，或者对于已“附加”到 Session 但不属于其待处理集合的瞬态对象生效。

  
  relationship.load_on_pending 标志没有改善 行为 - 对象引用应为 在对象级别构造，而不是在外键级别构造，因此 它们在 flush 进行之前以正常方式存在。 此标志并非不用于一般用途。

  
  另请参阅

  
  Session.enable_relationship_loading() - 此方法为整个对象建立 “Load on pending” 行为，并且还允许对保持 Transial 或 Detached 的对象进行加载。

• order_by –

  
  指示加载这些项时应应用的顺序。relationship.order_by 应指 列之一 目标类为的对象 mapped，或者将属性本身绑定到目标类，该 引用列。

  
  relationship.order_by 也可以作为 Callable 传递 函数，该函数在 Mapper 初始化时进行评估，并且可以 在使用 Declare 时作为 Python 可评估字符串传递。

  
  警告

  
  当作为 Python 可评估字符串传递时，将使用 Python 的 eval（） 函数解释参数。 不要将不受信任的输入传递给此字符串。有关 relationship（） 参数的声明性评估的详细信息，请参阅关系参数的评估。

• passive_deletes=False –

  
  指示删除作期间的加载行为。

  
  值为 True 表示在对父项执行删除作期间不应加载已卸载的子项。通常，删除父项时，将加载所有子项，以便可以将它们标记为已删除，或者将其父项的外键设置为 NULL。将此标志标记为 True 通常意味着 ON DELETE <CASCADE|SET NULL> 规则将处理数据库端的子行的更新/删除。

  
  此外，当父对象被删除并且没有启用删除或删除孤立级联时，将标志设置为字符串值 'all' 将禁用子外键的 “空”。这通常在数据库端存在触发或错误引发场景时使用。请注意，在发生 flush 后，session中子对象上的外键属性不会更改，因此这是一个非常特殊的用例设置。此外，如果子对象与父对象取消关联，则仍会发生“空”。

  
  另请参阅

  
  在 ORM 关系中使用外键 ON DELETE 级联 - 介绍性文档和示例。

• 
  passive_updates=真 –

  
  指示当引用的主键值发生更改时要采取的持久性行为，指示引用的外键列也需要更改其值。

  
  当 True 时，假定 ON UPDATE CASCADE 配置为 数据库中的外键，并且数据库将 处理 UPDATE 从源列到 dependent rows 的 Dependent Rows 进行更新。 当 False 时，SQLAlchemy 关系（） construct 将尝试将自己的 UPDATE 语句发送到 修改相关目标。 但是请注意，SQLAlchemy 不能 为多个级别的级联发出 UPDATE。 也 在以下情况下，将此标志设置为 False 是不兼容的 数据库实际上正在强制引用完整性，除非 这些约束是显式的 “deferred”，如果目标后端 支持它。

  
  强烈建议使用可变主键的应用程序将 passive_updates 设置为 True，而是使用数据库本身的引用完整性功能来高效、全面地处理更改。

  
  另请参阅

  
  可变主键/更新级联 - 介绍性文档和示例。

  
  mapper.passive_updates - 对联接表继承映射生效的类似标志。

• post_update –

  
  这表示该关系应由 INSERT 之后或 DELETE 之前的第二个 UPDATE 语句处理。此标志用于处理保存两个单独行之间的双向依赖关系（即每行引用另一行），否则将无法完全 INSERT 或 DELETE 两行，因为一行先于另一行。当特定的 Map 安排将产生两个相互依赖的行时，请使用此标志，例如一个表与一组子行具有一对多的关系，并且还有一个列引用该列表中的单个子行（即两个表都包含彼此的外键）。如果 flush作返回检测到 “cyclical dependency” 的错误，则表明您可能希望使用 relationship.post_update 来“打破”循环。

  
  另请参阅

  
  指向自身的行 / 相互依赖的行 - 介绍性文档和示例。

• 
  primaryjoin（主要连接 –

  
  一个 SQL 表达式，将用作子对象与父对象的主联接，或在多对多关系中用作父对象与关联表的联接。默认情况下，此值是根据父表和子表（或关联表）的外键关系计算的。

  
  relationship.primaryjoin 也可以作为可调用函数传递，该函数在 Mapper 初始化时进行评估，并且可以在使用 Declare 时作为 Python 可评估字符串传递。

  
  警告

  
  当作为 Python 可评估字符串传递时，将使用 Python 的 eval（） 函数解释参数。 不要将不受信任的输入传递给此字符串。有关 relationship（） 参数的声明性评估的详细信息，请参阅关系参数的评估。

  
  另请参阅

  
  指定备用联接条件

• remote_side –

  
  用于自引用关系，指示构成关系的“远程端”的列或列列表。

  
  relationship.remote_side也可以作为可调用函数传递，该函数在 mapper 初始化时进行评估，并且可以在使用 Declare 时作为 Python 可评估字符串传递。

  
  警告

  
  当作为 Python 可评估字符串传递时，将使用 Python 的 eval（） 函数解释参数。 不要将不受信任的输入传递给此字符串。有关 relationship（） 参数的声明性评估的详细信息，请参阅关系参数的评估。

  
  另请参阅

  
  邻接列表关系 - 深入解释如何 relationship.remote_side 用于配置自引用关系。

  
  remote（） - 一个注释函数，其目的与 relationship.remote_side 相同，通常在使用自定义 relationship.primaryjoin 条件时。

• query_class –

  
  查询 子类，该子类将由 AppenderQuery 由“动态”关系返回，即指定 lazy=“dynamic” 的关系或使用 dynamic_loader（） 功能。

  
  另请参阅

  
  动态关系加载器 - “动态”关系加载器简介。

• secondaryjoin –

  
  一个 SQL 表达式，将用作关联表与子对象的联接。默认情况下，此值是根据关联表和子表的外键关系计算的。

  
  relationship.secondaryjoin 也可以作为可调用函数传递，该函数在 Mapper 初始化时进行评估，并且可以在使用 Declare 时作为 Python 可评估字符串传递。

  
  警告

  
  当作为 Python 可评估字符串传递时，将使用 Python 的 eval（） 函数解释参数。 不要将不受信任的输入传递给此字符串。有关 relationship（） 参数的声明性评估的详细信息，请参阅关系参数的评估。

  
  另请参阅

  
  指定备用联接条件

• single_parent –

  
  如果为 True，则安装一个验证器，以防止对象一次与多个父项关联。这用于应视为一对一或一对多关系的多对一或多对多关系。它的用法是可选的，但 relationship（） 结构除外，这些结构是多对一或多对多，并且还指定了 delete-orphan cascade 选项。 这 relationship（） 结构本身将引发一个错误，指示何时需要此选项。

  
  另请参阅

  
  级联 - 包括有关何时 relationship.single_parent 标志可能合适。

• 
  使用列表 –

  
  一个布尔值，指示此属性是应作为列表还是标量加载。在大多数情况下，该值由 relationship（） 在 mapper 配置时自动确定。当使用显式 Mapped 注解时， relationship.uselist 可能派生自 Mapped 中的注解是否包含集合类。否则，relationship.uselist 可能派生自关系的类型和方向 - 一对多形成一个列表，多对一形成一个标量，多对多是一个列表。如果需要在通常存在列表的位置使用标量（例如双向一对一关系），请使用适当的 Mapped 注解或将 relationship.uselist 设置为 False。

  
  relationship.uselist 标志也可以在 现有关系（） construct 作为只读属性， 这可以用来确定这个 relationship（） 交易 with collections 或 scalar attributes：

  >>> User.addresses.property.uselist
  True

  
  另请参阅

  
  一对一 - “一对一”关系模式简介，这通常涉及 relationship.uselist 的替代设置。

• viewonly=False –

  
  设置为 True 时，关系仅用于加载 对象，而不是任何持久性作。 一个 relationship（） 指定 relationship.viewonly 可以工作 在 relationship.primaryjoin 条件，包括使用各种比较运算符以及 SQL 函数（如 cast（））的作。 这 relationship.viewonly flag 在定义任何类型的 relationship（） 来防止对集合的修改导致持久化作。

  
  另请参阅

  
  有关使用 viewonly 关系参数的说明 - 有关使用 relationship.viewonly 时的最佳实践的更多详细信息。

• sync_backref –

  
  一个布尔值，用于启用用于同步 Python 内部 属性（如果此关系是以下任一 relationship.backref 或 relationship.back_populates。

  
  默认为 None，这表示自动值应 根据 relationship.viewonly 标志。当保留为默认值时，仅当关系的两端都不是 viewonly 时，才会回填状态的更改。

  
  在 1.3.17 版本加入.

  
  在 1.4 版本发生变更： - 指定 relationship.viewonly 自动表示 relationship.sync_backref 为 False。

  
  另请参阅

  relationship.viewonly

• omit_join –

  
  允许手动控制 “selectin” 自动联接优化。设置为 False 以禁用 SQLAlchemy 1.3 中添加的 “省略连接” 功能;或保留为 None 以保留自动优化。

  
  注意

  
  此标志只能设置为 False。没有必要将其设置为 True，因为 “omit_join” 优化会自动检测;如果未检测到，则不支持优化。

  
  在 1.3.11 版本发生变更： 将 omit_join 设置为 True 现在将发出警告，因为这不是此标志的预期用途。

  
  在 1.3 版本加入.

• 
  init – 特定于声明性数据类映射，指定 mapped 属性是否应成为 __init__（） 的一部分 方法。

• 
  repr——特定于声明式数据类映射，指定映射的属性是否应该是 __repr__（） 的一部分 方法。

• 
  default_factory – 特定于 Declarative Dataclass Mapping，指定将作为 __init__（） 的一部分发生的默认值生成函数 方法。

• 
  比较 –

  
  特定于 Declarative Dataclass Mapping，指示此字段是否 在生成 __eq__（） 和 __ne__（） 方法。

  
  2.0.0b4 版本的新Function。

• 
  kw_only – 特定于 Declarative Dataclass Mapping，指示在生成 __init__（） 时是否应将此字段标记为仅关键字。

• 
  哈希 –

  
  特定于 Declarative Dataclass Mapping，控制在为映射的类生成 __hash__（） 方法时是否包含此字段。

  
  在 2.0.36 版本加入.

函数 sqlalchemy.orm 中。backref（name： str， **kwargs： Any）→ ORMBackrefArgument

使用 relationship.backref 参数时， 提供了在新建 relationship（） 生成。

例如：

"items": relationship(SomeItem, backref=backref("parent", lazy="subquery"))

relationship.backref 参数通常被认为是遗留的;对于现代应用程序，应首选使用通过 relationship.back_populates 参数链接在一起的显式 relationship（） 构造。

另请参阅

使用旧版 'backref' 关系参数 - backrefs 的背景

函数 sqlalchemy.orm 中。dynamic_loader（argument：_RelationshipArgumentType[Any]None=None， **kw： Any）→ RelationshipProperty[Any]

构造动态加载的 mapper 属性。

这基本上与在 relationship（） 中使用 lazy='dynamic' 参数相同：

dynamic_loader(SomeClass)

# is the same as

relationship(SomeClass, lazy="dynamic")

有关动态加载的更多详细信息，请参阅 Dynamic Relationship Loaders 部分。

函数 sqlalchemy.orm 中。foreign（expr： _CEA）→ _CEA

使用 'foreign' 注释注释 primaryjoin 表达式的一部分。

有关使用说明，请参阅 Creating Custom Foreign Conditions 部分。

另请参阅

创建自定义外部条件

远程（）

函数 sqlalchemy.orm 中。remote（expr： _CEA）→ _CEA

使用 'remote' 注释注释 primaryjoin 表达式的一部分。

有关使用说明，请参阅 Creating Custom Foreign Conditions 部分。

另请参阅

创建自定义外部条件

外语（）