动态 SQLAlchemy ORM 关系生成

Posted

技术标签:

【中文标题】动态 SQLAlchemy ORM 关系生成【英文标题】:Dynamic SQLAlchemy ORM relationship generation 【发布时间】:2018-07-21 21:02:35 【问题描述】:

前提:我有很多 表必须单独创建(它们不能动态创建),因此,我发现自己经常需要制作允许相关表的标准化:

class A_Table(Base):
    id = Column(Integer, primary_key=True)

class A_Relator(My_Mixin_Base):
    @declared_attr
    def a_table_id(cls):
        return Column(ForeignKey(A_Table.id))

    @declared_attr
    def a_table(cls):
        return relationship(A_Table)

class B_Table(A_Relator, Base):
    id = Column(Integer, primary_key=True)

class C_Table(A_Relator, Base):
    id = Column(Integer, primary_key=True)

class D_Table(A_Relator, Base):
    id = Column(Integer, primary_key=True)

# ad nauseam

很简单,但是当B_TableC_Table 等都有自己的 Relator 类时,它会变得非常重复,因此应该很容易在代码中解决。

我的解决方案:我创建了一个类工厂 (?),它创建了一个一次性使用的 mixin 类。

def related(clss, defined=False, altName=None):
    class X((Definer if defined else Relator),):
        linkedClass = clss

        @classmethod
        def linkedClassFieldName(cls):
            return "Id".format(clss.getBackrefName())

        def linkId(cls):
            return Column(ForeignKey(clss.id))

        def linkRe(cls):
            return relationship(clss,
                                foreign_keys=getattr(cls, "Id".format(clss.getBackrefName() if not altName else altName)),
                                backref=cls.getBackrefName())

    setattr(X, "Id".format(clss.getBackrefName() if not altName else altName), declared_attr(X.linkId))
    setattr(X,   "".format(clss.getBackrefName() if not altName else altName), declared_attr(X.linkRe))
    del X.linkId
    del X.linkRe

    return X

这允许您执行以下操作并完成它:

class B_Table(related(A_Table), Base):
    id = Column(Integer, primary_key=True)

...但这很混乱且令人困惑,我想有一种更好的方法可以做到这一点,从而减少不确定性。

问题:我正在寻找一种方法,以一种更直接的 SQLAlchemy 对齐方式来执行此操作,同时减少迂回的“hack”。或者总结一下:我如何制作一个生成关系的通用 SQLAlchemy mixin?

【问题讨论】:

嗨。在您的第一个示例代码块中,A_Relator 类中的ForeignKeyrelationship 被定义回您的A_Table 模型,对吗?在您的示例代码中,它们与未定义的模型 A 相关。 @SuperShoot 是的,对不起,你是对的。 【参考方案1】:

我对此一团糟。不确定此解决方案是否能满足您的需求,但我将其作为自己的学习练习,如果它对您有帮助,那就太好了。

因此,为了能够以尽可能少的输入在模型上定义外键和关系,这就是我想出的。

以下是我使用的模型:

class Base:
    @declared_attr
    def __tablename__(cls):
        return cls.__name__.lower()

    @declared_attr
    def id(cls):
        return Column(Integer, primary_key=True)

    def __repr__(self):
        return f'<type(self).__name__(id=self.id)>'

Base = declarative_base(cls=Base)

class A_Table(Base):
    parents = []

class B_Table(Base):
    parents = ['A_Table']

class C_Table(Base):
    parents = ['A_Table', 'B_Table']

注意每个模型上的类变量parents,它是一个字符串序列,应该是从同一个declarative_base 实例继承的其他模型名称。将在声明它们为父类的类上创建外键和与父类的关系。

然后利用以下事实:

属性可以在类构建之后添加到类中,并且它们 将添加到基础表和 mapper() 定义中 合适的

(见docs)

我遍历Base 上定义的所有模型,并根据给定的父对象构建所需的对象并将它们插入。

这是执行所有这些操作的函数:

from sqlalchemy import inspect  # this would be the only new import you'd need

def relationship_builder(Base):
    """ Finds all models defined on Base, and constructs foreign key
    columns and relationships on each as per their defined parent classes.

    """

    def make_fk_col(parent):
        """ Constructs a Column of the same type as the primary
        key of the parent and establishes it as a foreign key.
        Constructs a name for the foreign key column and attribute.

        """
        parent_pk = inspect(parent).primary_key[0]
        fk_name = f'parent.__name___parent_pk.name'
        col = Column(
            fk_name, parent_pk.type,
            ForeignKey(f'parent.__tablename__.parent_pk.name')
        )
        return fk_name, col

    # this bit gets all the models that are defined on Base and maps them to
    # their class name.
    models = 
        cls.__name__: cls  for cls in Base._decl_class_registry.values() if
        hasattr(cls, '__tablename__')
    

    for model in models.values():
        for parentname in model.parents:
            parent = models.get(parentname)
            if parent is not None:
                setattr(model, *make_fk_col(parent))
                rel = relationship(parent, backref=model.__name__)
                setattr(model, parentname, rel)

为了测试,这只是在我定义了其他所有内容的同一模块的底部:

if __name__ == '__main__':
    relationship_builder(Base)
    a = A_Table(id=1)
    b = B_Table(id=1)
    c = C_Table(id=1)
    a.B_Table.append(b)
    a.C_Table.append(c)
    b.C_Table.append(c)
    print(b.A_Table)
    print(c.A_Table)
    print(c.B_Table)
# <A_Table(id=1)>
# <A_Table(id=1)>
# <B_Table(id=1)>

这是它创建的架构:

这不适用于复合主键/外键,但我认为实现它不会太费力。如果len(inspect(parent).primary_keys) &gt; 1 你需要构建ForeignKeyConstraints 并将它们添加到表定义中,但我根本没有测试过。

我也认为,如果您可以以这样一种方式命名您的模型,即可以从模型本身的名称中推断出模型的从属关系,那么使其完全自动化也不会太过分。同样,只是大声思考。

【讨论】:

以上是关于动态 SQLAlchemy ORM 关系生成的主要内容,如果未能解决你的问题,请参考以下文章

我可以在 SQLAlchemy ORM 中使用动态关系(或视图)吗?

python ORM框架:SqlAlchemy

从 python 使用 TSQL(SQL Server 上的 mssql)时,如何为 SQLAlchemy 自动生成 ORM 代码?

SqlAlchemy ORM

ORM框架SQLAlchemy

Python 9 sqlalchemy ORM