如何使用automap_base生成(多到多)关系
作为背景:我正在创建一个基于现有数据库模式的ORM。-这是因为python应用程序不会是所述数据库的“所有者”。
在这个数据库中，有一个名为"task“的表和一个名为"task_notBefore__task_relatedTasks”的表，后者是"task“表中不同条目之间的多到多关系。
现在，automap_base()已经实现了对这些关系的自动检测，就像这里描述的那样。然而，对于我的情况来说，这是失败的，而且没有建立任何关系。
然后，我尝试手动创建这种关系：
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()然而，这仍然没有“做”任何事情:它没有向self.Task“类”添加任何内容。
一个人会怎么做？
回答 1
Stack Overflow用户
发布于 2018-03-21 06:08:27
在这种情况下，主要的问题不仅仅是多到多的关系，而是一种自我参照的、多对多的关系。因为automap只是简单地将映射的类名转换为关系名称，所以它为关系的两个方向构造相同的名称，例如task_collection，并且命名冲突会生成错误。automap的这一缺点很明显，因为自我参照的，多到多的关系并不少见.
使用自己的名称显式添加所需的关系不会解决问题，因为automap仍将尝试创建task_collection关系。为了解决这个问题，我们需要覆盖task_collection。
如果您可以将名称task_collection保留为关系的前进方向，我们可以简单地预定义关系--为backref指定我们想要的任何名称。如果automap发现预期的属性已经就位，它将假定关系正在被覆盖，而不尝试添加它。
下面是一个简化的示例，以及一个用于测试的sqlite数据库。
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.sqlPython代码
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',特别要注意的是，我实际上试图创建一个简单地覆盖关系名称而不预先定义它的解决方案。它显示了所描述的非决定论。
最后的想法
如果有相当数量的数据库表不经常更改，我建议只使用声明基。这可能是一些更多的工作设置，但它给你更多的控制。
https://stackoverflow.com/questions/49053739
复制相似问题
腾讯云开发者
