保存更新¶

save-update Cascade表示当一个对象被放置到 Session 通过 Session.add() ，所有与此关联的对象 relationship() 也应该添加到同一个 Session . 假设我们有一个物体 user1 有两个相关对象 address1 ， address2 ：：

>>> user1 = User()
>>> address1, address2 = Address(), Address()
>>> user1.addresses = [address1, address2]

如果我们增加 user1 到A Session ，它还将添加 address1 ， address2 隐含地：

>>> sess = Session()
>>> sess.add(user1)
>>> address1 in sess
True

save-update 层叠还影响已存在于 Session . 如果我们添加第三个对象， address3 到 user1.addresses 集合，它成为状态的一部分 Session ：：

>>> address3 = Address()
>>> user1.addresses.append(address3)
>>> address3 in sess
True

A save-update cascade在从集合中移除项或将对象与标量属性取消关联时，可能会表现出令人惊讶的行为。在某些情况下，孤立的对象仍可能被拉入前父对象的 Session ，这样刷新过程就可以适当地处理相关对象。这种情况通常只发生在一个对象被移除时 Session 并添加到另一个：

>>> user1 = sess1.query(User).filter_by(id=1).first()
>>> address1 = user1.addresses[0]
>>> sess1.close()   # user1, address1 no longer associated with sess1
>>> user1.addresses.remove(address1)  # address1 no longer associated with user1
>>> sess2 = Session()
>>> sess2.add(user1)   # ... but it still gets added to the new session,
>>> address1 in sess2  # because it's still "pending" for flush
True

这个 save-update 默认情况下，cascade是打开的，通常被认为是理所当然的；它通过允许对 Session.add() 在其中注册对象的整个结构 Session 马上。虽然它可以被禁用，但通常不需要这样做。

其中一例 save-update 层叠有时也会妨碍双向关系的发生，例如backrefs，这意味着子对象与特定父对象的关联可能具有父对象与子对象的隐式关联的效果。 Session ；此模式以及如何使用 relationship.cascade_backrefs 标志，在本节中讨论 在backrefs上控制级联 .

删除¶

这个 delete Cascade表示当“父”对象被标记为删除时，其相关的“子”对象也应标记为删除。例如，如果我们有关系 User.addresses 具有 delete 配置的层叠：

class User(Base):
    # ...

    addresses = relationship("Address", cascade="all, delete")

如果使用上面的映射，我们有一个 User 对象和两个相关 Address 物体：：

>>> user1 = sess.query(User).filter_by(id=1).first()
>>> address1, address2 = user1.addresses

如果我们做了记号 user1 对于删除，在执行刷新操作之后， address1 和 address2 也将被删除：

>>> sess.delete(user1)
>>> sess.commit()
DELETE FROM address WHERE address.id = ?
((1,), (2,))
DELETE FROM user WHERE user.id = ?
(1,)
COMMIT

或者，如果我们的 User.addresses 关系确实如此 not 有 delete 层叠，sqlAlchemy的默认行为是取消关联 address1 和 address2 从 user1 通过将其外键引用设置为 NULL . 使用如下映射：

class User(Base):
    # ...

    addresses = relationship("Address")

删除父级时 User 对象中的行 address 不删除，而是取消关联：

>>> sess.delete(user1)
>>> sess.commit()
UPDATE address SET user_id=? WHERE address.id = ?
(None, 1)
UPDATE address SET user_id=? WHERE address.id = ?
(None, 2)
DELETE FROM user WHERE user.id = ?
(1,)
COMMIT

删除 一对多关系上的级联通常与 删除孤儿 层叠，如果“子”对象从父对象中取消关联，将为相关行发出删除。结合 delete 和 delete-orphan cascade包括两种情况，其中sqlAlchemy必须决定将外键列设置为空，而不是完全删除行。

默认情况下，该功能完全独立于配置的数据库 FOREIGN KEY 约束本身可能配置 CASCADE 行为。为了更有效地与此配置集成，在 在具有ORM关系的DELETE cascade中使用外键 应该使用。

association_table = Table('association', Base.metadata,
    Column('left_id', Integer, ForeignKey('left.id')),
    Column('right_id', Integer, ForeignKey('right.id'))
)

class Parent(Base):
    __tablename__ = 'left'
    id = Column(Integer, primary_key=True)
    children = relationship(
        "Child",
        secondary=association_table,
        back_populates="parents",
        cascade="all, delete"
    )

class Child(Base):
    __tablename__ = 'right'
    id = Column(Integer, primary_key=True)
    parents = relationship(
        "Parent",
        secondary=association_table,
        back_populates="children",
    )

class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
    children = relationship(
        "Child", back_populates="parent",
        cascade="all, delete",
        passive_deletes=True
    )

class Child(Base):
    __tablename__ = 'child'
    id = Column(Integer, primary_key=True)
    parent_id = Column(Integer, ForeignKey('parent.id', ondelete="CASCADE"))
    parent = relationship("Parent", back_populates="children")

association_table = Table('association', Base.metadata,
    Column('left_id', Integer, ForeignKey('left.id', ondelete="CASCADE")),
    Column('right_id', Integer, ForeignKey('right.id', ondelete="CASCADE"))
)

class Parent(Base):
    __tablename__ = 'left'
    id = Column(Integer, primary_key=True)
    children = relationship(
        "Child",
        secondary=association_table,
        back_populates="parents",
        cascade="all, delete",
    )

class Child(Base):
    __tablename__ = 'right'
    id = Column(Integer, primary_key=True)
    parents = relationship(
        "Parent",
        secondary=association_table,
        back_populates="children",
        passive_deletes=True
    )

删除孤儿¶

delete-orphan 层叠将行为添加到 delete 层叠，这样当子对象与父对象取消关联时，子对象将被标记为删除，而不仅仅是在父对象被标记为删除时。这是处理父集合“拥有”的相关对象时的一个常见功能，该对象具有非空的外键，因此从父集合中删除该项会导致删除该项。

delete-orphan cascade意味着每个子对象一次只能有一个父对象 vast majority of cases is configured only on a one-to-many relationship. 对于将其设置为多对一或多对多关系的不太常见的情况，可以通过配置 relationship.single_parent 参数，它建立了Python端的验证，以确保对象一次只与一个父对象相关联，但是这极大地限制了“many”关系的功能，而且通常不是理想的。

合并¶

merge 层叠表示 Session.merge() 操作应该从父级传播，父级是 Session.merge() 调用引用的对象。默认情况下，此级联也处于启用状态。

刷新期满¶

refresh-expire 是一个不常见的选项，表示 Session.expire() 操作应该从父对象传播到被引用的对象。使用时 Session.refresh() ，引用的对象仅过期，但实际未刷新。

删去¶

expunge cascade表示当父对象从 Session 使用 Session.expunge() ，该操作应向下传播到引用的对象。

在backrefs上控制级联¶

在 1.x style ORM用法 保存更新 默认情况下，层叠发生在从backrefs发出的属性更改事件上。这可能是一个更容易通过演示描述的令人困惑的语句；这意味着，给定这样的映射：

mapper_registry.map_imperatively(Order, order_table, properties={
    'items' : relationship(Item, backref='order')
})

如果一个 Order 已在会话中，并分配给 order AN属性 Item ，backref附加了 Item 到 items 收集 Order ，导致 save-update 级联发生：

>>> o1 = Order()
>>> session.add(o1)
>>> o1 in session
True

>>> i1 = Item()
>>> i1.order = o1
>>> i1 in o1.items
True
>>> i1 in session
True

可以使用禁用此行为 relationship.cascade_backrefs 旗帜：

mapper_registry.map_imperatively(Order, order_table, properties={
    'items' : relationship(Item, backref='order', cascade_backrefs=False)
})

所以上面的任务 i1.order = o1 将追加 i1 到 items 收藏 o1 ，但不会添加 i1 参加会议。当然，你可以， Session.add() i1 稍后再参加会议。此选项可能有助于在对象构造完成之前将其从会话中保留出来，但仍需要将其与目标会话中已持久存在的对象关联。

当关系由 relationship.backref 参数打开 relationship() ，即 sqlalchemy.orm.cascade_backrefs 参数可以设置为 False 在BACKREF端使用 backref() 函数而不是字符串。例如，可以将上述关系声明为：：

mapper_registry.map_imperatively(Order, order_table, properties={
    'items' : relationship(
        Item, backref=backref('order', cascade_backrefs=False), cascade_backrefs=False
    )
})

这将设置 cascade_backrefs=False 两种关系的行为。

删除引用的对象和标量关系的注释¶

通常，ORM在刷新过程中从不修改集合或标量关系的内容。这意味着，如果你的班级 relationship() 如果引用了一个对象集合，或者引用了单个对象（如多对一），则在刷新过程发生时不会修改此属性的内容。相反，我们期望 Session 将最终过期，或者通过 Session.commit() 或通过明确使用 Session.expire() . 此时，任何与之关联的引用对象或集合 Session 将被清除，并在下次访问时重新加载。

在这种行为中出现的一种常见的混淆包括使用 Session.delete() 方法。什么时候？ Session.delete() 对对象和 Session 刷新后，该行将从数据库中删除。通过外键引用目标行的行，假定使用 relationship() 在两个映射对象类型之间，还将看到它们的外键属性更新为空，或者如果设置了删除层叠，则相关行也将被删除。但是，即使与已删除对象相关的行本身也可能被修改， no changes occur to relationship-bound collections or object references on the objects 参与冲洗本身范围内的操作。这意味着，如果对象是相关集合的成员，则在该集合过期之前，它仍然存在于Python端。同样，如果对象是通过多对一或一对一从另一个对象引用的，那么该引用将仍然存在于该对象上，直到该对象过期。

下面，我们举例说明 Address 对象已标记为删除，它仍存在于与父级关联的集合中 User ，即使冲洗后：

>>> address = user.addresses[1]
>>> session.delete(address)
>>> session.flush()
>>> address in user.addresses
True

提交上述会话后，所有属性都将过期。下一次访问 user.addresses 将重新加载集合，显示所需状态：

>>> session.commit()
>>> address in user.addresses
False

有一个拦截的秘诀 Session.delete() 并自动调用此过期时间；请参见 ExpireRelationshipOnFKChange 为了这个。但是，删除集合内的项的通常做法是放弃使用 Session.delete() 作为从父集合中移除对象的结果，直接使用级联行为自动调用删除。这个 delete-orphan CASCADE实现了这一点，如下例所示：

class User(Base):
    __tablename__ = 'user'

    # ...

    addresses = relationship(
        "Address", cascade="all, delete-orphan")

# ...

del user.addresses[1]
session.flush()

在上面的位置，移除 Address 对象从 User.addresses 收藏 delete-orphan 级联具有标记 Address 对象的删除方式与将其传递给 Session.delete() .

这个 delete-orphan 层叠还可以应用于多对一或一对一关系，这样当对象从其父级取消关联时，它也会自动标记为删除。使用 delete-orphan 在多对一或一对一上层叠需要附加标志 relationship.single_parent 它调用一个断言，即此相关对象不会同时与任何其他父对象共享：：

class User(Base):
    # ...

    preference = relationship(
        "Preference", cascade="all, delete-orphan",
        single_parent=True)

如果假设 Preference 对象从中移除 User ，它将在刷新时被删除：：

some_user.preference = None
session.flush()  # will delete the Preference object