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 。 設置可能需要更多的工作，但是它可以為您提供更多的控制權。