Question

如何编写一个模型，使其渴望递归地加载某个角色的父母和孩子。因此，不仅您现在要担任的角色的孩子，而且还是孩子。

您冒着以无限循环结尾的风险还是SQLAlchemy是否具有检测这些逻辑的逻辑？

SQLAlchemy模型如下：

from sqlalchemy.ext.declarative import declarative_base


roles_parents = Table(
'roles_parents', Base.metadata,
Column('role_id', Integer, ForeignKey('roles.id')),
Column('parent_id', Integer, ForeignKey('roles.id'))
)


Base = declarative_base()
class Role(Base):

    __tablename__ = 'roles'

id = Column(Integer, primary_key=True)
name = Column(String(20))
parents = relationship(
    'Role',
    secondary=roles_parents,
    primaryjoin=(id == roles_parents.c.role_id),
    secondaryjoin=(id == roles_parents.c.parent_id),
    backref=backref('children', lazy='joined'),
    lazy='joined'
)

def get_children(self):
    logger.log_dbg("get_children(self) with name: "  + self.name)
    for child in self.children:
        yield child
        for grandchild in child.get_children():
            yield grandchild

@staticmethod
def get_by_name(name):
    logger.log_dbg("get_by_name( " + name + " )")
    with DBManager().session_scope() as session:
        role = session.query(Role).options(joinedload(
            Role.children).joinedload(Role.parents)).filter_by(
            name=name).first()
        # role = session.query(Role).filter_by(name=name).first()
        session.expunge_all()
        return role

您可以看到，我尝试通过关系中的一个属性以及通过获取角色的查询中的选项来启用对父关系的渴望加载。

需要这种急切加载（和session.expunge_all（））的原因是，尝试通过get_children（）获取子项时，会话丢失了。

由于急切的加载，访问该角色的子角色时，get_children不再失败。但是，在尝试获取孙子项时仍然失败。因此，渴望加载似乎适合于子角色，但并不渴望加载其子角色。

Answer 1

基于this post的解决方案：

def recursive_expunge(obj, dbSession):
    def _recursive_expunge(_obj):
        _instance_state = sqlalchemy.inspection.inspect(_obj)
        if _instance_state.detached or _instance_state.transient:
          return
        _mapper = _instance_state.mapper
        try:
            dbSession.expunge(_obj)
        except sqlalchemy.orm.exc.UnmappedInstanceError:
            pass
        except sqlalchemy.exc.InvalidRequestError:
            pass
        if _mapper:
            _loaded_rels = [i for i in _mapper.relationships.items() if i[0] not in _instance_state.unloaded]
            for (_name, _rel) in _loaded_rels:
                _loaded_rel_data = getattr(_obj, _name)
                if _loaded_rel_data:
                    if not _rel.uselist:
                        _recursive_expunge(_loaded_rel_data)
                    else:
                        for _i in _loaded_rel_data:
                            _recursive_expunge(_i)
    _recursive_expunge(obj)

Answer 2

我很好奇为什么还要急于加载孙子孙女：用例是什么？

我问这个问题的原因是，我假设您可以通过访问当前子节点上的.children属性来在需要时访问孙子代。这样可以减少内存负荷（通过不递归地加载所有子项），并使处理当前节点（角色）更容易推理。

SQLAlchemy渴望加载递归模型

2 个答案: