SQLAlchemy: Rapport de la table avec une clé primaire composite

J'ai un ensemble de tableaux qui ressemblent à:

workflows = Table('workflows', Base.metadata,
                  Column('id', Integer, primary_key=True),
                 )

actions = Table('actions', Base.metadata,
                Column('name', String, primary_key=True),
                Column('workflow_id', Integer, ForeignKey(workflows.c.id), primary_key=True),
               )

action_dependencies = Table('action_dependencies', Base.metadata,
                            Column('workflow_id', Integer, ForeignKey(workflows.c.id), primary_key=True),
                            Column('parent_action', String, ForeignKey(actions.c.name), primary_key=True),
                            Column('child_action', String, ForeignKey(actions.c.name), primary_key=True),
                           )

Mon ORM classes ressembler à:

class Workflow(Base):
    __table__ = workflows

    actions = relationship("Action", order_by="Action.name", backref="workflow")


class Action(Base):
    __table__ = actions

    children = relationship("Action",
                            secondary=action_dependencies,
                            primaryjoin=actions.c.name == action_dependencies.c.parent_action,
                            secondaryjoin=actions.c.name == action_dependencies.c.child_action,
                            backref="parents"
                           )

Donc, dans mon système, chaque action est identifiée de manière unique par la combinaison d'un flux de travail id et son nom. J'aimerais que chaque action ont parents et children attribut qui désigne son parent et de l'enfant actions. Chaque action peut avoir plusieurs parents et les enfants.

Le problème survient lorsque j'ai une fonction telle que :

def set_parents(session, workflow_id, action_name, parents):
    action = session.query(db.Action).filter(db.Action.workflow_id == workflow.id).filter(db.Action.name == action_name).one()

    for parent_name in parents:
        parent = session.query(db.Action).filter(db.Action.workflow_id == workflow.id).filter(db.Action.name == parent_name).one()
        action.parents.append(parent)

    session.commit()

J'obtiens une erreur comme:

IntegrityError: (IntegrityError) action_dependencies.workflow_id may not be NULL u'INSERT INTO action_dependencies (parent_action, child_action) VALUES (?, ?)' (u'directory_creator', u'packing')

Comment puis-je obtenir la relation pour définir la workflow_id correctement?

Pourquoi avez-vous besoin d'avoir workflow_id dans le action_dependencies table?
Parce que la clé primaire pour une action est un composite de son nom et workflow_id. Si le workflow_id n'était pas dans action_dependencies, il n'y aurait aucun moyen de savoir de quel flux de travail les actions de la dépendance faisait allusion.
Bon point bon point. laissez-moi réfléchir...
Veuillez noter que votre parents/children les relations devraient également inclure la workflow_id dans le primaryjoin et secondary conditions, sinon vous allez obtenir ces pour tous les worklows.

OriginalL'auteur Kamil Kisiel | 2012-05-09

  1. 11

    Voir ci-dessous code de travail. Les points clés sont celles que j'ai mentionnées dans les commentaires:

    • bonne composite ForeignKeys
    • corriger relationship configuration à l'aide de la FKs

    Code:

    workflows = Table('workflows', Base.metadata,
Column('id', Integer, primary_key=True),
)
actions = Table('actions', Base.metadata,
Column('workflow_id', Integer, ForeignKey(workflows.c.id), primary_key=True),
Column('name', String, primary_key=True),
)
action_dependencies = Table('action_dependencies', Base.metadata,
Column('workflow_id', Integer, ForeignKey(workflows.c.id), primary_key=True),
Column('parent_action', String, ForeignKey(actions.c.name), primary_key=True),
Column('child_action', String, ForeignKey(actions.c.name), primary_key=True),
ForeignKeyConstraint(['workflow_id', 'parent_action'], ['actions.workflow_id', 'actions.name']),
ForeignKeyConstraint(['workflow_id', 'child_action'], ['actions.workflow_id', 'actions.name']),
)
class Workflow(Base):
__table__ = workflows
actions = relationship("Action", order_by="Action.name", backref="workflow")
class Action(Base):
__table__ = actions
children = relationship("Action",
secondary=action_dependencies,
primaryjoin=and_(actions.c.name == action_dependencies.c.parent_action,
actions.c.workflow_id == action_dependencies.c.workflow_id),
secondaryjoin=and_(actions.c.name == action_dependencies.c.child_action,
actions.c.workflow_id == action_dependencies.c.workflow_id),
backref="parents"
)
# create db schema
Base.metadata.create_all(engine)
# create entities
w_1 = Workflow()
w_2 = Workflow()
a_11 = Action(name="ac-11", workflow=w_1)
a_12 = Action(name="ac-12", workflow=w_1)
a_21 = Action(name="ac-21", workflow=w_2)
a_22 = Action(name="ac-22", workflow=w_2)
session.add(w_1)
session.add(w_2)
a_22.parents.append(a_21)
session.commit()
session.expunge_all()
print '-'*80
# helper functions
def get_workflow(id):
return session.query(Workflow).get(id)
def get_action(name):
return session.query(Action).filter_by(name=name).one()
# test another OK
a_11 = get_action("ac-11")
a_12 = get_action("ac-12")
a_11.children.append(a_12)
session.commit()
session.expunge_all()
print '-'*80
# test KO (THIS SHOULD FAIL VIOLATING FK-constraint)
a_11 = get_action("ac-11")
a_22 = get_action("ac-22")
a_11.children.append(a_22)
session.commit()
session.expunge_all()
print '-'*80

    OriginalL'auteur van

  2. 0

    Je ne pense pas que c'est correct pour la clé primaire clé étrangère. Comment cela fonctionne?

    Mais pour faire de composite contrainte, une clé qui est "unique", l'utiliser dans la définition de la table:

    UniqueConstraint(u"name", u"workflow_id"),

    Mais si vous voulez vraiment être la clé primaire aussi, vous pouvez utiliser ceci:

    PrimaryKeyConstraint(*columns, **kw)

    http://docs.sqlalchemy.org/en/latest/core/schema.html#sqlalchemy.schema.PrimaryKeyConstraint

    il n'y a rien de mal avec les contraintes de clé étrangère sur des clés primaires; c'est une méthode classique pour obtenir un "un-à-un" de la relation, à la carte des sous-classes de la base de données, ou pour avoir des attributs qui peuvent tous être "null ensemble"

    OriginalL'auteur Keith