关系 API

对象名称	描述
backref(name, **kwargs)	当使用 relationship.backref 参数时，提供在生成新的 relationship() 时要使用的特定参数。
dynamic_loader([argument], **kw)	构建一个动态加载的映射器属性。
foreign(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)	提供两个映射类之间的关系。
remote(expr)	使用 ‘remote’ 注解来注释 primaryjoin 表达式的一部分。

function sqlalchemy.orm.relationship(argument: _RelationshipArgumentType[Any] | None = None, secondary: _RelationshipSecondaryArgument | None = None, *, uselist: bool | None = None, collection_class: Type[Collection[Any]] | Callable[[], Collection[Any]] | None = None, primaryjoin: _RelationshipJoinConditionArgument | None = None, secondaryjoin: _RelationshipJoinConditionArgument | None = None, back_populates: str | None = None, order_by: _ORMOrderByArgument = False, backref: ORMBackrefArgument | None = None, overlaps: str | None = None, post_update: bool = False, cascade: str = 'save-update, merge', viewonly: bool = False, init: _NoArg | bool = _NoArg.NO_ARG, repr: _NoArg | bool = _NoArg.NO_ARG, default: _NoArg | _T = _NoArg.NO_ARG, default_factory: _NoArg | Callable[[], _T] = _NoArg.NO_ARG, compare: _NoArg | bool = _NoArg.NO_ARG, kw_only: _NoArg | bool = _NoArg.NO_ARG, hash: _NoArg | bool | None = _NoArg.NO_ARG, lazy: _LazyLoadArgumentType = 'select', passive_deletes: Literal['all'] | bool = False, passive_updates: bool = True, active_history: bool = False, enable_typechecks: bool = True, foreign_keys: _ORMColCollectionArgument | None = None, remote_side: _ORMColCollectionArgument | None = None, join_depth: int | None = None, comparator_factory: Type[RelationshipProperty.Comparator[Any]] | None = None, single_parent: bool = False, innerjoin: bool = False, distinct_target_key: bool | None = None, load_on_pending: bool = False, query_class: Type[Query[Any]] | None = None, info: _InfoType | None = None, omit_join: Literal[None, False] = None, sync_backref: bool | None = None, **kw: Any) → _RelationshipDeclared[Any]

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

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

另请参阅

使用 ORM 关联对象 - relationship() 的教程介绍，位于SQLAlchemy 统一教程中

关联配置 - 叙述性文档

参数:

• argument –

  此参数指的是要关联的类。它接受几种形式，包括直接引用目标类本身，目标类的 Mapper 实例，一个 Python 可调用对象 / lambda，它将在被调用时返回对类或 Mapper 的引用，以及最终的类的字符串名称，该名称将从正在使用的 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()

  另请参阅

  使用声明式定义映射属性 - 使用声明式时关于关系配置的更多细节。

• secondary –

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

  relationship.secondary 也可以作为可调用函数传递，该函数在映射器初始化时进行评估。当使用声明式时，它也可以是一个字符串参数，表示 Table 的名称，该表存在于与父映射 Table 关联的 MetaData 集合中。

  警告

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

  relationship.secondary 关键字参数通常应用于中间 Table 未在任何直接类映射中表达的情况。如果“secondary”表也在其他地方显式映射（例如，在 关联对象 中），则应考虑应用 relationship.viewonly 标志，以便此 relationship() 不用于持久化操作，这些操作可能与关联对象模式的操作冲突。

  另请参阅

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

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

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

  关联对象 - relationship.secondary 的替代方案，用于组合关联表关系，允许在关联表上指定其他属性。

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

• active_history=False – 当 True 时，表示在替换多对一引用时，如果尚未加载，则应加载“previous”值。通常，简单的多对一的历史跟踪逻辑只需要知道“new”值即可执行刷新。此标志适用于使用 get_history() 的应用程序，这些应用程序还需要知道属性的“previous”值。

• backref –

  对字符串关系名称或 backref() 构造的引用，它将用于在相关类上自动生成新的 relationship()，然后使用双向 relationship.back_populates 配置来引用此关系。

  在现代 Python 中，应优先显式使用带有 relationship.back_populates 的 relationship()，因为它在映射器配置方面更健壮，并且在概念上更直接。它还与 SQLAlchemy 2.0 中引入的新 PEP 484 类型提示功能集成，这在使用动态生成的属性时是不可能的。

  另请参阅

  使用旧版 ‘backref’ 关系参数 - 关于使用 relationship.backref 的说明

  使用 ORM 关联对象 - 在 SQLAlchemy 统一教程 中，概述了使用 relationship.back_populates 的双向关系配置和行为。

  backref() - 允许在使用 relationship.backref 时控制 relationship() 配置。

• back_populates –

  指示相关类上 relationship() 的名称，它将与此关系同步。通常期望相关类上的 relationship() 也引用此关系。这允许每个 relationship() 两侧的对象同步 Python 状态更改，并为 工作单元 刷新过程提供关于应如何持久化这些关系中的更改的指令。

  另请参阅

  使用 ORM 关联对象 - 在 SQLAlchemy 统一教程 中，概述了双向关系配置和行为。

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

  relationship.backref - 旧版形式，允许更简洁的配置，但不支持显式类型提示

• overlaps –

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

  1.4 版本新增。

  另请参阅

  关系 X 将列 Q 复制到列 P，这与关系 ‘Y’ 冲突 - 用法示例

• cascade –

  一个逗号分隔的级联规则列表，用于确定 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"，表示相关对象应在所有情况下都跟随父对象，并在取消关联时被删除。

  另请参阅

  级联 - 关于每个可用级联选项的完整详细信息。

• cascade_backrefs=False –

  旧版；此标志始终为 False。

  在 2.0 版本中更改: “cascade_backrefs” 功能已被移除。

• collection_class –

  一个类或可调用对象，它返回一个新的列表持有对象。将用于代替普通列表来存储元素。

  另请参阅

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

• comparator_factory –

  一个扩展 Comparator 的类，它为比较操作提供自定义 SQL 子句生成。

  另请参阅

  PropComparator - 关于在此级别重新定义比较器的一些细节。

  运算符自定义 - 此功能的简要介绍。

• distinct_target_key=None –

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

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

  另请参阅

  关系加载技术 - 包括子查询急切加载的介绍。

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

• foreign_keys –

  要用作“外键”列的列列表，或在本 relationship() 对象的 relationship.primaryjoin 条件上下文中，引用远程列中的值的列列表。也就是说，如果此 relationship() 的 relationship.primaryjoin 条件是 a.id == b.a_id，并且 b.a_id 中的值必须存在于 a.id 中，那么此 relationship() 的“外键”列是 b.a_id。

  在正常情况下，不需要 relationship.foreign_keys 参数。relationship() 将自动确定 relationship.primaryjoin 条件中的哪些列应被视为“外键”列，这基于指定了 Column 对象 ForeignKey，或在 ForeignKeyConstraint 构造中被列为引用列。relationship.foreign_keys 仅在以下情况下需要：

  1. 从本地表到远程表构建连接的方式不止一种，因为存在多个外键引用。设置 foreign_keys 将限制 relationship() 仅考虑此处指定的作为“外键”的列。

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

  3. relationship.primaryjoin 参数用于构造非标准的连接条件，该条件使用通常不引用其“父”列的列或表达式，例如通过使用 SQL 函数的复杂比较来表示的连接条件。

  当遇到不明确的条件时，relationship() 构造将引发信息丰富的错误消息，建议使用 relationship.foreign_keys 参数。在典型情况下，如果 relationship() 没有引发任何异常，则通常不需要 relationship.foreign_keys 参数。

  relationship.foreign_keys 也可以作为在映射器初始化时评估的可调用函数传递，并且在使用 Declarative 时可以作为 Python 可评估的字符串传递。

  警告

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

  另请参阅

  处理多条连接路径

  创建自定义外键条件

  foreign() - 允许直接注释 relationship.primaryjoin 条件中的“外键”列。

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

• innerjoin=False –

  当 True 时，连接的迫切加载将使用内连接来连接相关表，而不是外连接。此选项的目的通常是出于性能考虑，因为内连接通常比外连接执行得更好。

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

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

  另请参阅

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

  应该使用哪种加载方式？ - 讨论各种加载器选项的一些细节。

• join_depth –

  当非 None 时，一个整数值，指示“迫切”加载器应在自引用或循环关系上连接多少层深度。该数字计算沿特定连接分支的加载条件中应存在同一 Mapper 的次数。当保留默认值 None 时，迫切加载器将在遇到链中已较高的同一目标映射器时停止链接。此选项同时适用于连接加载器和子查询加载器。

  另请参阅

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

• lazy='select' –

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

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

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

  • joined - 项应使用 JOIN 或 LEFT OUTER JOIN 在与父项相同的查询中“迫切地”加载。连接是否为“外部”连接由 relationship.innerjoin 参数确定。

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

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

  • noload - 任何时候都不应进行加载。相关集合将保持为空。noload 策略不建议用于一般用途。对于一般用途的“永不加载”方法，请参阅 只写关系

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

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

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

    当在 Declarative 映射中的左侧提供 WriteOnlyMapped 注释时，会自动配置 write_only 加载器样式。有关示例，请参阅 只写关系 部分。

    2.0 版本中的新功能。

    另请参阅

    只写关系 - 在 ORM 查询指南 中

  • dynamic - 该属性将为所有读取操作返回预配置的 Query 对象，可以在迭代结果之前对其应用进一步的过滤操作。

    当在 Declarative 映射中的左侧提供 DynamicMapped 注释时，会自动配置 dynamic 加载器样式。有关示例，请参阅 动态关系加载器 部分。

    遗留功能

    “dynamic”延迟加载器策略是现在 只写关系 部分中描述的“write_only”策略的遗留形式。

    另请参阅

    动态关系加载器 - 位于 ORM 查询指南 中

    仅写入关系 - 对于不应完全加载到内存的大型集合，这是一种更通用的方法

  • True - ‘select’ 的同义词

  • False - ‘joined’ 的同义词

  • None - ‘noload’ 的同义词

  另请参阅

  关系加载技术 - 关于关系加载器配置的完整文档，请参阅 ORM 查询指南。

• load_on_pending=False –

  指示瞬态或待定父对象的加载行为。

  当设置为 True 时，会导致惰性加载器为非持久化的父对象（意味着它从未被刷新）发出查询。当自动刷新禁用时，或者对于已“附加”到 Session 但不属于其待定集合的瞬态对象，这可能会生效。

  relationship.load_on_pending 标志在正常使用 ORM 时不会改善行为 - 对象引用应在对象级别而不是外键级别构建，以便它们在刷新进行之前以普通方式存在。此标志并非旨在用于通用用途。

  另请参阅

  Session.enable_relationship_loading() - 此方法为整个对象建立“load on pending”行为，并允许在保持瞬态或分离的对象上进行加载。

• order_by –

  指示加载这些项时应应用的排序。relationship.order_by 预计引用目标类映射到的 Column 对象之一，或绑定到引用列的目标类的属性本身。

  relationship.order_by 也可以作为在映射器初始化时评估的可调用函数传递，并且在使用声明式时可以作为 Python 可评估的字符串传递。

  警告

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

• passive_deletes=False –

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

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

  此外，当父对象被删除且未启用删除或删除孤立级联时，将标志设置为字符串值 ‘all’ 将禁用子外键的“置空”。当数据库端存在触发或引发错误的情况时，通常使用此方法。请注意，在刷新发生后，会话内子对象上的外键属性将不会更改，因此这是一个非常特殊的用例设置。此外，如果子对象与父对象解除关联，“置空”仍将发生。

  另请参阅

  将外键 ON DELETE 级联与 ORM 关系一起使用 - 介绍性文档和示例。

• passive_updates=True –

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

  当为 True 时，假定在外键上配置了 ON UPDATE CASCADE，并且数据库将处理从源列到依赖行的 UPDATE 传播。当为 False 时，SQLAlchemy relationship() 构造将尝试发出自己的 UPDATE 语句来修改相关目标。但是请注意，SQLAlchemy 不能发出超过一级的级联 UPDATE。此外，如果数据库实际上正在强制执行引用完整性，除非这些约束被显式“延迟”（如果目标后端支持），否则将此标志设置为 False 是不兼容的。

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

  另请参阅

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

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

• post_update –

  这表示关系应通过 INSERT 之后或 DELETE 之前的第二个 UPDATE 语句来处理。此标志用于处理两个单独行之间的双向依赖关系（即，每行都引用另一行）的保存，否则不可能完全 INSERT 或 DELETE 两行，因为其中一行在另一行之前存在。当特定的映射安排将导致两行相互依赖时，请使用此标志，例如一个表与一组子行具有一对多关系，并且还具有引用该列表中单个子行的列（即，两个表都包含指向彼此的外键）。如果刷新操作返回错误，检测到“循环依赖”，则提示您可能需要使用 relationship.post_update 来“打破”循环。

  另请参阅

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

• primaryjoin –

  一个 SQL 表达式，将用作子对象相对于父对象的主连接，或者在多对多关系中，用作父对象到关联表的连接。默认情况下，此值基于父表和子表（或关联表）的外键关系计算得出。

  relationship.primaryjoin 也可以作为在映射器初始化时评估的可调用函数传递，并且在使用声明式时可以作为 Python 可评估的字符串传递。

  警告

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

  另请参阅

  指定备用连接条件

• remote_side –

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

  relationship.remote_side 也可以作为在映射器初始化时评估的可调用函数传递，并且在使用声明式时可以作为 Python 可评估的字符串传递。

  警告

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

  另请参阅

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

  remote() - 一个注释函数，可实现与 relationship.remote_side 相同的目的，通常在使用自定义 relationship.primaryjoin 条件时使用。

• query_class –

  一个 Query 子类，将由“动态”关系返回的 AppenderQuery 在内部使用，即指定了 lazy="dynamic" 的关系，或者以其他方式使用 dynamic_loader() 函数构建的关系。

  另请参阅

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

• secondaryjoin –

  一个 SQL 表达式，将用作关联表到子对象的连接。默认情况下，此值基于关联表和子表的外键关系计算得出。

  relationship.secondaryjoin 也可以作为在映射器初始化时评估的可调用函数传递，并且在使用声明式时可以作为 Python 可评估的字符串传递。

  警告

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

  另请参阅

  指定备用连接条件

• single_parent –

  当为 True 时，安装一个验证器，该验证器将阻止对象一次与多个父对象关联。这用于应被视为一对一或一对多的多对一或多对多关系。它的使用是可选的，但 relationship() 构造是多对一或多对多，并且还指定了 delete-orphan 级联选项的情况除外。relationship() 构造本身将引发一个错误，指示何时需要此选项。

  另请参阅

  级联 - 包括关于何时 relationship.single_parent 标志可能适用的详细信息。

• uselist –

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

  relationship.uselist 标志也可在现有的 relationship() 构造上作为只读属性使用，可用于确定此 relationship() 处理集合还是标量属性

  >>> User.addresses.property.uselist
  True

  另请参阅

  一对一 - “一对一”关系模式简介，这通常是在涉及 relationship.uselist 的备用设置时。

• viewonly=False –

  当设置为 True 时，此关联仅用于加载对象，而不用于任何持久化操作。 指定了 relationship() 并指定了 relationship.viewonly，可以与 relationship.primaryjoin 条件内更广泛的 SQL 操作一起使用，包括使用各种比较运算符以及 SQL 函数（如 cast()）的操作。 当定义任何不代表完整相关对象集的 relationship() 时，relationship.viewonly 标志也通常用于防止对集合的修改导致持久化操作。

  另请参阅

  关于使用 viewonly 关联参数的注意事项 - 更多关于使用 relationship.viewonly 的最佳实践的详细信息。

• sync_backref –

  一个布尔值，用于启用事件，当此关联是 relationship.backref 或 relationship.back_populates 的目标时，用于同步 Python 属性。

  默认为 None，表示应根据 relationship.viewonly 标志的值选择一个自动值。 当保留其默认值时，只有当关联的任何一方都不是 viewonly 时，状态的更改才会被反向填充。

  1.3.17 版本新增。

  在 1.4 版本中变更：- 指定了 relationship.viewonly 的关联自动意味着 relationship.sync_backref 为 False。

  另请参阅

  relationship.viewonly

• omit_join –

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

  注意

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

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

  1.3 版本新增。

• init – 特定于 声明式数据类映射，指定映射属性是否应作为 dataclass 进程生成的 __init__() 方法的一部分。

• repr – 特定于 声明式数据类映射，指定映射属性是否应作为 dataclass 进程生成的 __repr__() 方法的一部分。

• default_factory – 特定于 声明式数据类映射，指定一个默认值生成函数，该函数将作为 dataclass 进程生成的 __init__() 方法的一部分执行。

• compare –

  特定于 声明式数据类映射，指示在为映射类生成 __eq__() 和 __ne__() 方法时，是否应将此字段包含在比较操作中。

  2.0.0b4 版本新增。

• kw_only – 特定于 声明式数据类映射，指示在生成 __init__() 时，是否应将此字段标记为仅关键字。

• hash –

  特定于 声明式数据类映射，控制在为映射类生成 __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’ 关联参数 - 关于反向引用的背景知识

函数 sqlalchemy.orm.dynamic_loader(argument: _RelationshipArgumentType[Any] | None = None, **kw: Any) → RelationshipProperty[Any]

构建一个动态加载的映射器属性。

这本质上与将 lazy='dynamic' 参数与 relationship() 一起使用相同

dynamic_loader(SomeClass)

# is the same as

relationship(SomeClass, lazy="dynamic")

有关动态加载的更多详细信息，请参阅《动态关联加载器》部分。

函数 sqlalchemy.orm.foreign(expr: _CEA) → _CEA

使用 ‘foreign’ 注解来注释 primaryjoin 表达式的一部分。

有关使用说明，请参阅《创建自定义外键条件》部分。

另请参阅

创建自定义外键条件

remote()

函数 sqlalchemy.orm.remote(expr: _CEA) → _CEA

使用 ‘remote’ 注解来注释 primaryjoin 表达式的一部分。

有关使用说明，请参阅《创建自定义外键条件》部分。

另请参阅

创建自定义外键条件

foreign()