SQLAlchemy Mapping-Tabelle Spalten mit Filtern

Question

Ich habe eine Tabelle in PostgreSQL, die Informationen über Dokumente enthält. Sagen wir so etwas wie das:

table: doc 

id (int) 
name (string) 
type (int) 

Typ eine Kategorie für ein Dokument (z 1 - Reisepass, 2 - Versicherung usw.). Außerdem habe ich verschiedene Tabellen mit zusätzlichen Informationen für jeden Dosierungs-Typ.

table: info 

id (int) 
doc_id (fk) 
info (additional columns) 

Ich möchte ein SQLAlchemy Modell haben, mit jeder Art von Dokument mit seinen zusätzlichen Informationen und der Lage sein, Spalten verknüpft arbeiten zu verwalten (für Flask-Admin, wenn es wichtig ist) angezeigt werden soll.

nun zwei Tabellen in eine Art „Modells“ Ich Mapping Table Columns wie die von der SQLAlchemy Dokumentation verwendet zu verbinden (wenn es nur eine Art von Dokumenten war):

class DocMapping(db.Model): 

    __table__ = doc.__table__.join(info) 
    __mapper_args__ = { 
     'primary_key': [doc.__table__.c.id] 
    } 

Die Frage ist nun, dass: Wie erstellt man mehrere Klassen, die von db.Model (DocPassportMapping, DocInsuranceMapping usw.) geerbt wurden, basierend auf der Spalte doc.type?

So etwas:

__table__ = doc.__table__.join(info).filter(doc.type) 

Das funktioniert natürlich nicht, weil wir nicht hier ein Abfrage Objekt haben.

Answer 1

Wenn ich Sie richtig verstanden habe, möchten Sie eine inheritance hierarchy basierend auf DocMapping mit DocMapping.type als die polymorphe Identität haben. Da Sie kein vollständiges Beispiel angegeben haben, ist hier eine etwas ähnliche Struktur. Es hat sicherlich Unterschiede, sollte aber auf Sie zutreffen. Dies verwendet single table inheritance oben auf dem verknüpften Mapping.

Die Modelle:

In [2]: class Doc(Base): 
    ...:  id = Column(Integer, primary_key=True, autoincrement=True) 
    ...:  name = Column(Unicode) 
    ...:  type = Column(Integer, nullable=False) 
    ...:  __tablename__ = 'doc' 
    ...:  

In [3]: class Info(Base): 
    ...:  __tablename__ = 'info' 
    ...:  doc_id = Column(Integer, ForeignKey('doc.id'), primary_key=True) 
    ...:  value = Column(Unicode) 
    ...:  doc = relationship('Doc', backref=backref('info', uselist=False)) 
    ...:  

In [4]: class DocMapping(Base): 
    ...:  __table__ = Doc.__table__.join(Info) 
    ...:  __mapper_args__ = { 
    ...:   'primary_key': (Doc.id,), 
    ...:   # These declare this mapping polymorphic 
    ...:   'polymorphic_on': Doc.type, 
    ...:   'polymorphic_identity': 0, 
    ...:  } 
    ...:  

In [5]: class Passport(DocMapping): 
    ...:  __mapper_args__ = { 
    ...:   'polymorphic_identity': 1, 
    ...:  } 
    ...:  

In [6]: class Insurance(DocMapping): 
    ...:  __mapper_args__ = { 
    ...:   'polymorphic_identity': 2, 
    ...:  } 
    ...:  

Testing:

In [7]: session.add(Insurance(name='Huono vakuutus', 
    ...:      value='0-vakuutus, mitään ei kata')) 

In [8]: session.commit() 

In [15]: session.query(DocMapping).all() 
Out[15]: [<__main__.Insurance at 0x7fdc0a086400>] 

In [16]: _[0].name, _[0].value 
Out[16]: ('Huono vakuutus', '0-vakuutus, mitään ei kata') 

Die Sache ist die: Sie wahrscheinlich nicht mehrere Klassen wollen, die von db.Model als Basis erben, sondern Klassen, die von DocMapping erben. Es macht viel mehr Sinn als Hierarchie.