Einstellung löschen-Waise auf SQLAlchemy Beziehung führt zu AssertionError: Diese AttributeImpl ist nicht konfiguriert zu verfolgen Eltern

dies ist meine Flask-SQLAlchemy Deklarative code:

from sqlalchemy.ext.associationproxy import association_proxy
from my_flask_project import db


tagging = db.Table('tagging',
    db.Column('tag_id', db.Integer, db.ForeignKey('tag.id', ondelete='cascade'), primary_key=True),
    db.Column('role_id', db.Integer, db.ForeignKey('role.id', ondelete='cascade'), primary_key=True)
)


class Tag(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), unique=True, nullable=False)

    def __init__(self, name=None):
        self.name = name

    @classmethod
    def delete_orphans(cls):
        for tag in Tag.query.outerjoin(tagging).filter(tagging.c.role_id == None):
            db.session.delete(tag)


class Role(db.Model):

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id', ondelete='cascade'))
    user = db.relationship('User', backref=db.backref('roles', cascade='all', lazy='dynamic'))
    ...
    tags = db.relationship('Tag', secondary=tagging, cascade='all', backref=db.backref('roles', cascade='all'))
    tag_names = association_proxy('tags', 'name')

    __table_args__ = (
        db.UniqueConstraint('user_id', 'check_id'),
    )

Grundsätzlich, es ' s viele-zu-viele-Kennzeichnung mit Deklarativen. Beim löschen einiger Einträge aus-tagging, ich will SQLAlchemy zum Aufräumen des Waisen. Wie ich in Google docs, um dieses feature zu aktivieren, sollte ich dies tun:

class Role(db.Model):
    ...
    tags = db.relationship('Tag', secondary=tagging, cascade='all,delete-orphan', backref=db.backref('roles', cascade='all'))
    ...

Jedoch, eine solche Einstellung führt zu AssertionError: Diese AttributeImpl ist nicht konfiguriert zu verfolgen Eltern. Ich habe es gegoogelt und nichts gefunden, außer der opensourced code von SQLAlchemy. Daher habe ich die classmethod Tag.delete_orphans() (es ist im obigen code) aufrufen, um es jedes mal, wenn ich denke, einige Waisen, die auftreten konnten, aber das scheint nicht sehr elegant.

Irgendwelche Ideen oder Erklärungen, warum meine Einstellung mit delete-orphan funktioniert nicht?

InformationsquelleAutor Honza Javorek | 2012-02-10

OK, in diesem Fall müssen Sie genauer hinsehen, aber es ist eine Warnung, dass hier möglicherweise eine Ausnahme geworden, und ich werde in diesem Blick. Hier ist eine funktionierende version von deinem Beispiel:

from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy import *
from sqlalchemy.orm import *
from sqlalchemy.ext.declarative import declarative_base

Base= declarative_base()

tagging = Table('tagging',Base.metadata,
    Column('tag_id', Integer, ForeignKey('tag.id', ondelete='cascade'), primary_key=True),
    Column('role_id', Integer, ForeignKey('role.id', ondelete='cascade'), primary_key=True)
)

class Tag(Base):

    __tablename__ = 'tag'
    id = Column(Integer, primary_key=True)
    name = Column(String(100), unique=True, nullable=False)

    def __init__(self, name=None):
        self.name = name

class Role(Base):
    __tablename__ = 'role'

    id = Column(Integer, primary_key=True)
    tag_names = association_proxy('tags', 'name')

    tags = relationship('Tag', 
                        secondary=tagging, 
                        cascade='all,delete-orphan', 
                        backref=backref('roles', cascade='all'))


e = create_engine("sqlite://", echo=True)

Base.metadata.create_all(e)

s = Session(e)

r1 = Role()
r1.tag_names.extend(["t1", "t2", "t3"])
s.add(r1)
s.commit()

Nun laufen lasst:

... creates tables
/Users/classic/dev/sqlalchemy/lib/sqlalchemy/orm/properties.py:918: SAWarning: On Role.tags, delete-orphan cascade is not supported on a many-to-many or many-to-one relationship when single_parent is not set.   Set single_parent=True on the relationship().
  self._determine_direction()
Traceback (most recent call last):
  ... stacktrace ...
  File "/Users/classic/dev/sqlalchemy/lib/sqlalchemy/orm/attributes.py", line 349, in hasparent
    assert self.trackparent, "This AttributeImpl is not configured to track parents."
AssertionError: This AttributeImpl is not configured to track parents.

So, hier ist der wichtige Teil: SAWarning: Auf Rolle.tags -, delete-orphan cascade nicht unterstützt, auf eine viele-zu-viele oder viele-zu-eins-Beziehung, wenn single_parent ist nicht festgelegt. Set single_parent=True auf die Beziehung().

Damit der Fehler behoben ist, wenn Sie sagen:

tags = relationship('Tag', 
                    secondary=tagging, 
                    cascade='all,delete-orphan', 
                    single_parent=True,
                    backref=backref('roles', cascade='all'))

Aber, das Sie beobachten können, dass das nicht wirklich das, was Sie wollen:

r1 = Role()
r2 = Role()

t1, t2 = Tag("t1"), Tag("t2")
r1.tags.extend([t1, t2])
r2.tags.append(t1)

Ausgabe:

sqlalchemy.exc.InvalidRequestError: Instance <Tag at 0x101503a10> is already associated with an instance of <class '__main__.Role'> via its Role.tags attribute, and is only allowed a single parent.

Dass Ihre "alleinerziehende" - die "delete-orphan" - Funktion funktioniert nur mit dem, was heißt ein lifecycle Beziehung, wo das Kind besteht ausschließlich im Rahmen der single-Eltern. Es gibt also praktisch keinen Sinn, mit einer viele-zu-viele " mit "orphan", und es ist nur unterstützt, weil einige Leute wirklich, wirklich wollte, um dieses Verhalten mit einer Zuordnung Tabelle unabhängig (legacy-DB-Zeug, vielleicht).

Heres der doc für die:

delete-orphan cascade bedeutet, dass jedes Kind-Objekt kann nur eine
Eltern in einer Zeit, die so konfiguriert ist, in der überwiegenden Mehrzahl der Fälle auf eine
eins-zu-viele-Beziehung. Einstellung auf eine viele-zu-eins oder viele-zu-viele
Beziehung ist mehr umständlich; für diesen Anwendungsfall, SQLAlchemy erfordert
dass die Beziehung() konfiguriert werden, mit der single_parent=True
Funktion, die eine Python-seitige Validierung, die sicherstellt, dass die
Objekt verbunden ist, mit nur einem Elternteil zu einem Zeitpunkt.

Was ist impliziert, wenn Sie sagen, "ich will es zu reinigen, die Waisen" ? Es würde hier bedeuten, dass, wenn Sie sagen r1.tags.remove(t1), dann Sie sagte, "flush". SQLAlchemy sehen würde, "r1.tags t1 entfernt wurde, und wenn es eine Waise müssen wir löschen!!! OK, also lasst uns gehen, "tagging" und dann scan die gesamte Tabelle für alle Einträge, die bleiben. "Um dies naiv für jeden tag-in einer Zeit, klar wäre wirklich ineffizient, wenn Sie betroffen sind ein paar hundert tag-Sammlungen in einer Sitzung, da würde es ein paar hundert von diesen potenziell enorme Abfragen. Zu tun, um so weniger, als naiv wäre eine ziemlich komplizierte Funktion hinzufügen, wie die Einheit der Arbeit neigt dazu, zu denken, in Bezug auf die Sammlung zu einem Zeit - und es würde noch hinzufügen, spürbar Abfrage overhead, dass die Leute vielleicht wirklich nicht wollen. Die Einheit der Arbeit tut, was es tut wirklich gut, doch er versucht, sich aus dem Geschäft der ungewöhnliche Grenzfälle, die add viel Komplexität und überraschungen. In der Realität, die "delete-orphan" - system kommt nur ins Spiel, wenn ein Objekt B ist losgelöst von einem Objekt im Speicher - es gibt keinen scan der Datenbank, oder ähnliches, es ist viel einfacher als das - und die flush-Prozess hat um die Dinge so einfach wie möglich.

Also, was machst du hier mit "löschen " Waisen" ist auf dem richtigen Weg, aber wir stecken Sie in ein Ereignis, und verwenden auch eine effizientere Abfrage und löschen alles was wir nicht brauchen, in einem Rutsch:

from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy import *
from sqlalchemy.orm import *
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import event

Base= declarative_base()

tagging = Table('tagging',Base.metadata,
    Column('tag_id', Integer, ForeignKey('tag.id', ondelete='cascade'), primary_key=True),
    Column('role_id', Integer, ForeignKey('role.id', ondelete='cascade'), primary_key=True)
)

class Tag(Base):

    __tablename__ = 'tag'
    id = Column(Integer, primary_key=True)
    name = Column(String(100), unique=True, nullable=False)

    def __init__(self, name=None):
        self.name = name

class Role(Base):
    __tablename__ = 'role'

    id = Column(Integer, primary_key=True)
    tag_names = association_proxy('tags', 'name')

    tags = relationship('Tag', 
                        secondary=tagging,
                        backref='roles')

@event.listens_for(Session, 'after_flush')
def delete_tag_orphans(session, ctx):
    session.query(Tag).\
        filter(~Tag.roles.any()).\
        delete(synchronize_session=False)

e = create_engine("sqlite://", echo=True)

Base.metadata.create_all(e)

s = Session(e)

r1 = Role()
r2 = Role()
r3 = Role()
t1, t2, t3, t4 = Tag("t1"), Tag("t2"), Tag("t3"), Tag("t4")

r1.tags.extend([t1, t2])
r2.tags.extend([t2, t3])
r3.tags.extend([t4])
s.add_all([r1, r2, r3])

assert s.query(Tag).count() == 4

r2.tags.remove(t2)

assert s.query(Tag).count() == 4

r1.tags.remove(t2)

assert s.query(Tag).count() == 3

r1.tags.remove(t1)

assert s.query(Tag).count() == 2

nun mit jedem flush bekommen wir diese Abfrage am Ende:

DELETE FROM tag WHERE NOT (EXISTS (SELECT 1 
FROM tagging, role 
WHERE tag.id = tagging.tag_id AND role.id = tagging.role_id))

Also brauchen wir nicht zum ziehen von Objekten in den Speicher, um Sie zu löschen, wenn wir löschen können, auf eine einfache SQL-Kriterium (unter Berufung auf das ziehen von Zeilen in den Speicher, wenn die Datenbank kann über Operationen effizienter wurde als Reihe von qualvollen Zeile Programmierung). Die "not EXISTS" funktioniert sehr gut, wenn die Suche für das fehlen einer zusammenhängenden Reihe zu, im Vergleich zu den OUTER-JOIN, die tendenziell teurer werden die Planer.

Tolle Antwort. Vielen Dank für die so detaillierte und ausführliche Erklärung und danke für den funktionierenden code. Ich bin froh zu erfahren und zu verstehen, mehr von SQLAlchemy Beispiel arbeiten, weil es schwierig zu Lesen und bekommen es alle aus der Theorie in docs.
Wirklich eine ausgezeichnete Antwort!
Fantastische Antwort - danke
weiter loben :), Echt genial Antwort

InformationsquelleAutor zzzeek

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.