作为背景：我正在基于现有数据库的模式创建ORM。 - 这是因为python应用程序不是＆＃34;所有者＆＃34;所述数据库。
现在在这个数据库中有一个名为＆＃34; task＆＃34;的表。和一个名为＆＃34; task_notBefore__task_relatedTasks＆＃34; - 后者是＆＃34; task＆＃34;中不同条目之间的多对多关系。表
现在automap_base()可以自动检测这些关系，如here所述。然而，这对我的情况来说是失败的，并且没有建立任何关系。
然后我尝试手动创建关系：
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.ext.automap import generate_relationship
from sqlalchemy.orm import sessionmaker, interfaces, relationship
from sqlalchemy import create_engine
class DBConnection:
def __init__(self, connection_url, **kwargs):
self.engine = create_engine(connection_url, **kwargs)
self._Base = automap_base()
self._Base.prepare(self.engine, reflect=True)
self.Task = self._Base.classes.task
self.Order = self._Base.classes.order
self.Poller = self._Base.classes.poller
rel = generate_relationship(self._Base, interfaces.MANYTOMANY, relationship, 'related', self.Task, self.Task,
secondary=self._Base.classes.task_notBefore__task_relatedTasks, backref='notBefore')
self._Session = sessionmaker()
self._Session.configure(bind=self.engine)
self.session = self._Session()
然而，这仍然没有＆＃34;做＆＃34;任何事情：它不会向self.Task＆＃34;类＆＃34;添加任何内容。
如何做到这一点？
答案 0 :(得分：1)
在这种情况下，主要问题不仅仅是多对多关系，而是它是一种自我参照，多对多的关系。因为automap只是将映射的类名转换为关系名，所以它构造了相同的名称，例如task_collection，对于关系的两个方向，命名冲突都会生成错误。 automap的这个缺点在于自我指涉，多对多关系并不罕见。
使用您自己的名称明确添加所需的关系无法解决问题，因为automap仍会尝试创建task_collection关系。要解决此问题，我们需要覆盖task_collection。
如果您保持名称task_collection为关系的前进方向，我们可以简单地预先定义关系 - 指定我们想要的backref名称。如果automap找到了预期的属性，它将假定该关系被覆盖而不是尝试添加它。
这是一个精简的示例，以及一个用于测试的sqlite数据库。
CREATE TABLE task (
id INTEGER,
name VARCHAR,
PRIMARY KEY (id)
);
CREATE TABLE task_task (
tid1 INTEGER,
tid2 INTEGER,
FOREIGN KEY(tid1) REFERENCES task(id),
FOREIGN KEY(tid2) REFERENCES task(id)
);
-- Some sample data
INSERT INTO task VALUES (0, 'task_0');
INSERT INTO task VALUES (1, 'task_1');
INSERT INTO task VALUES (2, 'task_2');
INSERT INTO task VALUES (3, 'task_3');
INSERT INTO task VALUES (4, 'task_4');
INSERT INTO task_task VALUES (0, 1);
INSERT INTO task_task VALUES (0, 2);
INSERT INTO task_task VALUES (2, 4);
INSERT INTO task_task VALUES (3, 4);
INSERT INTO task_task VALUES (3, 0);
将其放入名为setup_self.sql的文件中，我们可以：
sqlite3 self.db < setup_self.sql
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base
DeclBase = declarative_base()
task_task = Table('task_task', DeclBase.metadata,
Column('tid1', Integer, ForeignKey('task.id')),
Column('tid2', Integer, ForeignKey('task.id')))
Base = automap_base(DeclBase)
class Task(Base):
__tablename__ = 'task'
task_collection = relationship('Task',
secondary=task_task,
primaryjoin='Task.id==task_task.c.tid1',
secondaryjoin='Task.id==task_task.c.tid2',
backref='backward')
engine = create_engine("sqlite:///self.db")
Base.prepare(engine, reflect=True)
session = Session(engine)
task_0 = session.query(Task).filter_by(name ='task_0').first()
task_4 = session.query(Task).filter_by(name ='task_4').first()
print("task_0.task_collection = {}".format([x.name for x in task_0.task_collection]))
print("task_4.backward = {}".format([x.name for x in task_4.backward]))
task_0.task_collection = ['task_1', 'task_2']
task_4.backward = ['task_2', 'task_3']
如果您希望使用task_collection以外的名称，则需要使用automap函数来覆盖收集关系名称：
name_for_collection_relationship(base, local_cls, referred_cls, constraint)
参数local_cls和referred_cls是映射表类的实例。对于自我指涉，多对多的关系，这些都属于同一类。我们可以使用参数来构建一个允许我们识别覆盖的密钥。
以下是此方法的示例实现。
from sqlalchemy.ext.automap import automap_base, name_for_collection_relationship
from sqlalchemy.orm import Session
from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base
DeclBase = declarative_base()
task_task = Table('task_task', DeclBase.metadata,
Column('tid1', Integer, ForeignKey('task.id')),
Column('tid2', Integer, ForeignKey('task.id')))
Base = automap_base(DeclBase)
class Task(Base):
__tablename__ = 'task'
forward = relationship('Task',
secondary=task_task,
primaryjoin='Task.id==task_task.c.tid1',
secondaryjoin='Task.id==task_task.c.tid2',
backref='backward')
# A dictionary that maps relationship keys to a method name
OVERRIDES = {
'Task_Task' : 'forward'
}
def _name_for_collection_relationship(base, local_cls, referred_cls, constraint):
# Build the key
key = '{}_{}'.format(local_cls.__name__, referred_cls.__name__)
# Did we have an override name?
if key in OVERRIDES:
# Yes, return it
return OVERRIDES[key]
# Default to the standard automap function
return name_for_collection_relationship(base, local_cls, referred_cls, constraint)
engine = create_engine("sqlite:///self.db")
Base.prepare(engine, reflect=True, name_for_collection_relationship=_name_for_collection_relationship)
请注意，覆盖name_for_collection_relationship只会更改automap用于关系的名称。在我们的例子中，关系仍由Task预先定义。但是，覆盖会让automap查找forward而不是task_collection，它会找到它，因此会停止定义关系。
在某些情况下，如果我们可以覆盖关系名称而不必预先定义实际关系，那就太好了。首先考虑，应该可以使用name_for_collection_relationship。但是，由于两个原因的结合，我无法让这种方法适用于自我引用，多对多的关系。
name_for_collection_relationship和相关的generate_relationship被调用两次，一次针对多对多关系的每个方向。在这两种情况下，由于自我指涉性，local_cls和referred_cls是相同的。而且，name_for_collection_relationship的其他论点实际上是等价的。因此，我们不能从函数调用的上下文中确定我们覆盖的方向。
这是问题的更令人惊讶的部分。看来我们甚至不能指望一个方向发生在另一个方向之前。换句话说，对name_for_collection_relationship和generate_relationship的两次调用非常相似。实际决定关系方向性的论点是constraint，这是关系的两个外键约束之一;这些约束从Base.metadata加载到名为m2m_const的变量中。这就是问题所在。约束在m2m_const中结束的顺序是不确定的，即有时它将是一个顺序;其他时候则相反（至少在使用sqlite3时）。因此，这种关系的方向性是不确定的。
另一方面，当我们预先定义关系时，以下参数会创建必要的决定论。
primaryjoin='Task.id==task_task.c.tid1',
secondaryjoin='Task.id==task_task.c.tid2',
特别值得注意的是，我实际上试图创建一个简单地覆盖关系名称而不预先定义它的解决方案。它表现出所描述的不确定性。
如果您有合理数量的数据库表不经常更改，我建议您只使用Declarative Base。设置可能需要更多工作，但它可以让您获得更多控制权。