多对多关联对象和定义的所有关系在删除时崩溃

Question

当具有描述了所有关系的完全多对多关系时，两个主要对象之一的删除将崩溃。

描述

车 （ .car_ownerships ）< - >（ .car ）CarOwnership（ .person ）< - >（ .car_ownerships ） 人

汽车 （ .people ）<----------------->（. .cars ） 人

问题

删除汽车或个人 SA时，首先删除关联对象CarOwnership （由于与secondary参数的“直通”关系），然后尝试将相同关联对象中的外键更新为NULL，从而崩溃。

我该如何解决？ 我有些困惑，看不到文档中也找不到我可以在网上找到的任何地方，因为我认为这种模式很常见：-/。 我想念什么？

我知道我可以为through关系打开passive_deletes ，但是我想保留delete语句，只是为了防止更新发生（或使更新发生在前面）。

编辑 ：实际上，如果从属对象在会话中加载， passive_deletes不能解决问题，因为仍然会发出DELETE语句。 一个解决方案是使用viewonly=True ，但是这样我不仅失去了删除，而且失去了关联对象的自动创建。 我还发现viewonly=True非常危险，因为它使您无需持久化append()即可！

REPEX

设定

from sqlalchemy import create_engine, Table, Column, Integer, String, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship, backref, sessionmaker

engine = create_engine('sqlite:///:memory:', echo = False)
Base = declarative_base()
Session = sessionmaker(bind=engine)
session = Session()


class Person(Base):
    __tablename__ = 'persons'

    id = Column(Integer(), primary_key=True)
    name = Column(String(255))

    cars = relationship('Car', secondary='car_ownerships', backref='people')

    def __repr__(self):
        return '<Person {} [{}]>'.format(self.name, self.id)

class Car(Base):
    __tablename__ = 'cars'

    id = Column(Integer(), primary_key=True)
    name = Column(String(255))

    def __repr__(self):
        return '<Car {} [{}]>'.format(self.name, self.id)


class CarOwnership(Base):
    __tablename__ = 'car_ownerships'

    id = Column(Integer(), primary_key=True)
    type = Column(String(255))
    car_id = Column(Integer(), ForeignKey(Car.id))
    car = relationship('Car', backref='car_ownerships')
    person_id = Column(Integer(), ForeignKey(Person.id))
    person = relationship('Person', backref='car_ownerships')

    def __repr__(self):
        return 'Ownership [{}]: {} <<-{}->> {}'.format(self.id, self.car, self.type, self.person)

Base.metadata.create_all(engine)

归档对象

antoine = Person(name='Antoine')
rob = Person(name='Rob')
car1 = Car(name="Honda Civic")
car2 = Car(name='Renault Espace')

CarOwnership(person=antoine, car=car1, type = "secondary")
CarOwnership(person=antoine, car=car2, type = "primary")
CarOwnership(person=rob, car=car1, type = "primary")

session.add(antoine)
session.commit()

session.query(CarOwnership).all()

删除->崩溃

print('#### DELETING')
session.delete(car1)
print('#### COMMITING')
session.commit()


# StaleDataError                            Traceback (most recent call last)
# <ipython-input-6-80498b2f20a3> in <module>()
#       1 session.delete(car1)
# ----> 2 session.commit()
# ...

诊断

我上面提出的解释是由引擎使用echo=True给出的SQL语句支持的：

#### DELETING
#### COMMITING
2016-07-07 16:55:28,893 INFO sqlalchemy.engine.base.Engine SELECT persons.id AS persons_id, persons.name AS persons_name 
FROM persons, car_ownerships 
WHERE ? = car_ownerships.car_id AND persons.id = car_ownerships.person_id
2016-07-07 16:55:28,894 INFO sqlalchemy.engine.base.Engine (1,)
2016-07-07 16:55:28,895 INFO sqlalchemy.engine.base.Engine SELECT car_ownerships.id AS car_ownerships_id, car_ownerships.type AS car_ownerships_type, car_ownerships.car_id AS car_ownerships_car_id, car_ownerships.person_id AS car_ownerships_person_id 
FROM car_ownerships 
WHERE ? = car_ownerships.car_id
2016-07-07 16:55:28,896 INFO sqlalchemy.engine.base.Engine (1,)
2016-07-07 16:55:28,898 INFO sqlalchemy.engine.base.Engine DELETE FROM car_ownerships WHERE car_ownerships.car_id = ? AND car_ownerships.person_id = ?
2016-07-07 16:55:28,898 INFO sqlalchemy.engine.base.Engine ((1, 1), (1, 2))
2016-07-07 16:55:28,900 INFO sqlalchemy.engine.base.Engine UPDATE car_ownerships SET car_id=? WHERE car_ownerships.id = ?
2016-07-07 16:55:28,900 INFO sqlalchemy.engine.base.Engine ((None, 1), (None, 2))
2016-07-07 16:55:28,901 INFO sqlalchemy.engine.base.Engine ROLLBACK

EDITS

使用association_proxy

我们可以使用关联代理来尝试并实现“直通”关系。

不过，为了直接.append()一个依赖对象，我们需要为关联对象创建一个构造函数。 此构造函数必须被“破解”以使其成为双向的，因此我们可以使用两种分配：

my_car.people.append(Person(name='my_son'))
my_husband.cars.append(Car(name='new_shiny_car'))

生成的（经过中等测试的）代码在下面，但是我对此不太满意（由于这个构造怪异的构造函数，还有什么要打破的？）。

编辑：与关联代理一起使用的方法在下面的RazerM的答案中提出。 association_proxy()具有一个创建者参数，该参数减轻了我最终在下面使用的怪异构造函数的需求。

class Person(Base):
    __tablename__ = 'persons'

    id = Column(Integer(), primary_key=True)
    name = Column(String(255))

    cars = association_proxy('car_ownerships', 'car')

    def __repr__(self):
        return '<Person {} [{}]>'.format(self.name, self.id)

class Car(Base):
    __tablename__ = 'cars'

    id = Column(Integer(), primary_key=True)
    name = Column(String(255))

    people = association_proxy('car_ownerships', 'person')

    def __repr__(self):
        return '<Car {} [{}]>'.format(self.name, self.id)


class CarOwnership(Base):
    __tablename__ = 'car_ownerships'

    id = Column(Integer(), primary_key=True)
    type = Column(String(255))
    car_id = Column(Integer(), ForeignKey(Car.id))
    car = relationship('Car', backref='car_ownerships')
    person_id = Column(Integer(), ForeignKey(Person.id))
    person = relationship('Person', backref='car_ownerships')

    def __init__(self, car=None, person=None, type='secondary'):
        if isinstance(car, Person):
            car, person = person, car
        self.car = car
        self.person = person
        self.type = type        

    def __repr__(self):
        return 'Ownership [{}]: {} <<-{}->> {}'.format(self.id, self.car, self.type, self.person)

Answer 1

您正在使用关联对象 ，因此您需要做不同的事情。

我已经改变了这里的关系，请仔细查看它们，因为起初缠绕头有点困难（至少对我来说是如此！）。

我使用了back_populates因为在这种情况下，它比backref更清晰。 多对多关系的双方都必须直接引用CarOwnership ，因为这是您要使用的对象。 这也是您的示例所显示的内容； 您需要使用它才能设置type 。

class Person(Base):
    __tablename__ = 'persons'

    id = Column(Integer(), primary_key=True)
    name = Column(String(255))

    cars = relationship('CarOwnership', back_populates='person')

    def __repr__(self):
        return '<Person {} [{}]>'.format(self.name, self.id)


class Car(Base):
    __tablename__ = 'cars'

    id = Column(Integer(), primary_key=True)
    name = Column(String(255))

    people = relationship('CarOwnership', back_populates='car')

    def __repr__(self):
        return '<Car {} [{}]>'.format(self.name, self.id)


class CarOwnership(Base):
    __tablename__ = 'car_ownerships'

    id = Column(Integer(), primary_key=True)
    type = Column(String(255))
    car_id = Column(Integer(), ForeignKey(Car.id))
    person_id = Column(Integer(), ForeignKey(Person.id))

    car = relationship('Car', back_populates='people')
    person = relationship('Person', back_populates='cars')

    def __repr__(self):
        return 'Ownership [{}]: {} <<-{}->> {}'.format(self.id, self.car, self.type, self.person)

请注意，删除任一侧后， car_ownerships行将不会被删除，它只会将外键设置为NULL。 如果您想设置自动删除功能，可以在答案中添加更多内容。

编辑：要直接访问Car和Person对象的集合，您需要使用association_proxy ，然后将类更改为此：

from sqlalchemy.ext.associationproxy import association_proxy

class Person(Base):
    __tablename__ = 'persons'

    id = Column(Integer(), primary_key=True)
    name = Column(String(255))

    cars = association_proxy(
        'cars_association', 'car', creator=lambda c: CarOwnership(car=c))

    def __repr__(self):
        return '<Person {} [{}]>'.format(self.name, self.id)


class Car(Base):
    __tablename__ = 'cars'

    id = Column(Integer(), primary_key=True)
    name = Column(String(255))

    people = association_proxy(
        'people_association', 'person', creator=lambda p: CarOwnership(person=p))

    def __repr__(self):
        return '<Car {} [{}]>'.format(self.name, self.id)


class CarOwnership(Base):
    __tablename__ = 'car_ownerships'

    id = Column(Integer(), primary_key=True)
    type = Column(String(255), default='secondary')
    car_id = Column(Integer(), ForeignKey(Car.id))
    person_id = Column(Integer(), ForeignKey(Person.id))

    car = relationship('Car', backref='people_association')
    person = relationship('Person', backref='cars_association')

    def __repr__(self):
        return 'Ownership [{}]: {} <<-{}->> {}'.format(self.id, self.car, self.type, self.person)

编辑：在编辑中，将其转换为使用backref 。 您的汽车和人的关联代理不能同时使用“ car_ownerships”关系，这就是为什么我有一个名为“ people_association”和一个名为“ cars_association”的原因。

您拥有的“ car_ownerships”关系与关联表称为“ car_ownerships”的事实无关，因此，为什么我以不同的方式命名它们。

我已经修改了上面的代码块。 要允许添加工作，您需要将创建者添加到关联代理。 我将back_populates更改为backref ，并将默认type添加到Column对象而不是构造函数中。

Answer 2

最干净的解决方案如下，并且不涉及关联代理。 这是成熟的多对多关系所缺少的秘诀。

在这里，我们编辑从从属对象Car和Person到关联对象CarOwnership的直接关系，以防止在删除关联对象后这些关系发出UPDATE 。 为此，我们使用passive_deletes='all'标志。

产生的交互是：

• 从相关对象查询和设置关联对象的能力

    # Changing Ownership type:
    my_car.car_ownerships[0].type = 'primary'
    # Creating an ownership between a car and a person directly:
    CarOwnership(car=my_car, person=my_husband, type='primary')

• 直接访问和编辑相关对象的能力：

   # Get all cars from a person: [print(c) for c in my_husband.cars] # Update the name of one of my cars: me.cars[0].name = me.cars[0].name + ' Cabriolet' 

• 创建或删除从属对象时自动创建和删除关联对象

   # Create a new owner and assign it to a car: my_car.people.append(Person('my_husband')) session.add(my_car) session.commit() # Creates the necessary CarOwnership # Delete a car: session.delete(my_car) session.commit() # Deletes all the related CarOwnership objects 

码

class Person(Base):
    __tablename__ = 'persons'

    id = Column(Integer(), primary_key=True)
    name = Column(String(255))

    cars = relationship('Car', secondary='car_ownerships', backref='people')

    def __repr__(self):
        return '<Person {} [{}]>'.format(self.name, self.id)

class Car(Base):
    __tablename__ = 'cars'

    id = Column(Integer(), primary_key=True)
    name = Column(String(255))

    def __repr__(self):
        return '<Car {} [{}]>'.format(self.name, self.id)


class CarOwnership(Base):
    __tablename__ = 'car_ownerships'

    id = Column(Integer(), primary_key=True)
    type = Column(String(255))
    car_id = Column(Integer(), ForeignKey(Car.id))
    car = relationship('Car', backref=backref('car_ownerships', passive_deletes='all'))
    person_id = Column(Integer(), ForeignKey(Person.id))
    person = relationship('Person', backref=backref('car_ownerships', passive_deletes='all'))

    def __repr__(self):
        return 'Ownership [{}]: {} <<-{}->> {}'.format(self.id, self.car, self.type, self.person)