如何为SQLAlchemy大型遗留模型设计属性受限的部分视图类？

问题背景 #

现有一个无法重构的大型遗留SQLAlchemy/Flask-SQLAlchemy模型，它聚合了多个逻辑独立的模块。我们需要基于子模型设计权限控制，限制对属性（甚至方法）子集的读写操作，需满足以下核心要求：

• 保留原模型的底层实现，支持.query等ORM操作；
• 实例加载/初始化后，仅允许访问类级指定的属性子集。

原模型结构示例：

class MyLargeModel(db.Model):
   id = db.Column(db.Integer, primary_key=True)
   foo = db.Column(db.Text, nullable=False)
   bar = db.Column(db.Text, nullable=False)
   baz = db.Column(db.Text, nullable=False)

期望拆分后的结构（需补充属性限制逻辑）：

class ModelBase(db.Model):
   id = db.Column(db.Integer, primary_key=True)

class FooView(ModelBase):
   foo = db.Column(db.Text, nullable=False)

class BarView(ModelBase):
   bar = db.Column(db.Text, nullable=False)

class BarbazView(BarView):
   baz = db.Column(db.Text, nullable=False)

class MyLargeModel(FooView, BarbazView):
   pass

要求每个视图类尽可能保留SQLAlchemy模型特性（如加载、理想情况下支持持久化），功能类似SQLA-Marshmallow的Schema，但需保留实际ORM模型。另外，SQLAlchemy的单表继承需要polymorphic_on列做垂直拆分，不符合我们仅需水平拆分属性的需求。

解决方案设计 #

方案1：元类驱动的属性访问控制Mixin #

通过自定义元类和Mixin，在实例层面拦截属性读写，仅允许访问预定义的属性列表。该方案无需修改原模型映射，灵活性高。

实现代码

from flask_sqlalchemy import Model
from sqlalchemy.ext.declarative import DeclarativeMeta

class RestrictedAttrMeta(DeclarativeMeta):
    def __new__(cls, name, bases, attrs):
        # 合并父类与当前类的允许属性列表
        allowed_attrs = {'id'}
        for base in bases:
            if hasattr(base, 'allowed_attrs'):
                allowed_attrs.update(base.allowed_attrs)
        if 'allowed_attrs' in attrs:
            allowed_attrs.update(attrs['allowed_attrs'])
        attrs['allowed_attrs'] = allowed_attrs
        return super().__new__(cls, name, bases, attrs)

class RestrictedViewMixin:
    __metaclass__ = RestrictedAttrMeta
    allowed_attrs = {'id'}

    def __getattr__(self, name):
        if name not in self.allowed_attrs:
            raise AttributeError(f"属性 '{name}' 不允许访问")
        return super().__getattribute__(name)

    def __setattr__(self, name, value):
        if name not in self.allowed_attrs and not name.startswith('_'):
            raise AttributeError(f"属性 '{name}' 不允许修改")
        super().__setattr__(name, value)

# 拆分视图类（标记为抽象类，避免生成单独表）
class ModelBase(db.Model, RestrictedViewMixin):
    __abstract__ = True
    id = db.Column(db.Integer, primary_key=True)

class FooView(ModelBase):
    __abstract__ = True
    foo = db.Column(db.Text, nullable=False)
    allowed_attrs = {'foo'}

class BarView(ModelBase):
    __abstract__ = True
    bar = db.Column(db.Text, nullable=False)
    allowed_attrs = {'bar'}

class BarbazView(BarView):
    __abstract__ = True
    baz = db.Column(db.Text, nullable=False)
    allowed_attrs = {'baz'}

# 原遗留模型保持不变
class MyLargeModel(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    foo = db.Column(db.Text, nullable=False)
    bar = db.Column(db.Text, nullable=False)
    baz = db.Column(db.Text, nullable=False)

# 使用示例：包装原模型实例为视图类
def get_restricted_instance(model_cls, view_cls, id):
    obj = model_cls.query.get(id)
    view_obj = view_cls()
    view_obj.__dict__ = obj.__dict__
    return view_obj

# 测试访问限制
foo_view = get_restricted_instance(MyLargeModel, FooView, 1)
print(foo_view.foo)  # 正常访问
foo_view.bar = "test"  # 抛出AttributeError

方案2：映射原表的视图模型 #

直接定义抽象视图模型，映射到原表的指定列，利用SQLAlchemy的ORM特性实现属性限制，支持原生.query操作。

实现代码

class ModelBase(db.Model):
    __abstract__ = True
    id = db.Column(db.Integer, primary_key=True)

class FooView(ModelBase):
    __tablename__ = 'my_large_model'  # 映射到原表名
    foo = db.Column(db.Text, nullable=False)

class BarView(ModelBase):
    __tablename__ = 'my_large_model'
    bar = db.Column(db.Text, nullable=False)

class BarbazView(BarView):
    __tablename__ = 'my_large_model'
    baz = db.Column(db.Text, nullable=False)

# 原遗留模型保持不变
class MyLargeModel(db.Model):
    __tablename__ = 'my_large_model'
    id = db.Column(db.Integer, primary_key=True)
    foo = db.Column(db.Text, nullable=False)
    bar = db.Column(db.Text, nullable=False)
    baz = db.Column(db.Text, nullable=False)

# 使用示例：直接查询视图模型
foo_instance = FooView.query.get(1)
print(foo_instance.foo)  # 正常访问
print(foo_instance.bar)  # 抛出AttributeError（FooView未定义该列）

# 支持持久化（仅修改视图类中定义的列）
foo_instance.foo = "updated value"
db.session.commit()

方案对比 #

总结 #

• 若需严格的属性访问控制且保留原模型灵活性，优先选择元类Mixin方案；
• 若更关注原生ORM查询支持与性能，优先选择视图模型方案。

两种方案均无需修改遗留模型结构，完全满足需求。

内容的提问来源于stack exchange，提问作者Dave