sqlalchemy如何使用automap_base生成（多对多）关系

Question

作为背景：我正在基于现有数据库的架构创建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 “类”添加任何东西。

一个人怎么做？

Answer 1

在这种情况下，主要问题不仅在于多对多关系，还在于它是一种自我参照的多对多关系。 因为automap只是将映射的类名转换为关系名，所以它为关系的两个方向构造相同的名称，例如task_collection ，并且命名冲突会产生错误。 自automap的多对多关系并不少见，因此automap这一缺点非常重要。

使用您自己的名称显式添加所需的关系不会解决该问题，因为automap task_collection仍会尝试创建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.sql

Python代码

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 task_collection查找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结束的m2m_const是不确定的，即有时是一个顺序。 其他时间则相反（至少在使用sqlite3 ）。 因此，关系的方向性是不确定的。

另一方面，当我们预先定义关系时，以下参数会创建必要的确定性。

primaryjoin='Task.id==task_task.c.tid1',
secondaryjoin='Task.id==task_task.c.tid2',

需要特别注意的是，我实际上试图创建一种解决方案，该解决方案简单地覆盖关系名称而不预先定义它。 它表现出了所描述的不确定性。

最后的想法

如果您有数量合理且不经常更改的数据库表，我建议您仅使用Declarative Base 。 设置可能需要更多的工作，但是它可以为您提供更多的控制权。