Sqlalchemy 如何在多个多态继承表上查询关系？

假设您有以下简化的示例模式，它使用SQLAlchemy联接表多态继承<代码>工程师和

分析师

模型具有

角色

关系。

Intern

型号没有

class Role(db.Model):

    __tablename__ = 'role'

    id = db.Column(db.Integer, primary_key=True)

    name = db.Column(db.String(16), index=True)

class EmployeeBase(db.Model):

    __tablename__ = 'employee_base'

    id = db.Column(db.Integer, primary_key=True)

    some_attr = db.Column(db.String(16))
    another_attr = db.Column(db.String(16))

    type = db.Column(db.String(50), index=True)

    __mapper_args__ = {
        'polymorphic_identity': 'employee',
        'polymorphic_on': type
    }

class Engineer(EmployeeBase):

    __tablename__ = 'engineer'

    id = db.Column(db.Integer, db.ForeignKey('employee_base.id'), primary_key=True)

    role_id = db.Column(db.Integer, db.ForeignKey('role.id'), index=True)
    role = db.relationship('Role', backref='engineers')

    __mapper_args__ = {
        'polymorphic_identity': 'engineer',
    }

class Analyst(EmployeeBase):

    __tablename__ = 'analyst'

    id = db.Column(db.Integer, db.ForeignKey('employee_base.id'), primary_key=True)

    role_id = db.Column(db.Integer, db.ForeignKey('role.id'), index=True)
    role = db.relationship('Role', backref='analysts')

    __mapper_args__ = {
        'polymorphic_identity': 'analyst',
    }

class Intern(EmployeeBase):

    __tablename__ = 'intern'

    id = db.Column(db.Integer, db.ForeignKey('employee_base.id'), primary_key=True)

    term_ends = db.Column(db.DateTime, index=True, nullable=False)

    __mapper_args__ = {
        'polymorphic_identity': 'intern',
    }

如果我想找到具有

角色的
员工
姓名
在姓名的某个地方有“石油”，我该怎么做？

我试过很多很多方法。我最接近的是这个，它只返回
Analyst
匹配项：

employee_role_join = with_polymorphic(EmployeeBase, 
    [Engineer, Analyst])
results = db.session.query(employee_role_join).join(Role).filter(Role.name.ilike('%petroleum%'))

如果我尝试这样做，我会得到一个
AttributeError
，因为我正在搜索加入的
角色
表的属性：

employee_role_join = with_polymorphic(EmployeeBase, 
    [Engineer, Analyst])
results = db.session.query(employee_role_join).filter(or_(
    Engineer.role.name.ilike('%petroleum%'),
    Analyst.role.name.ilike('%petroleum%')))

在
EmployeeBase
上定义
role\u id
。即使Intern没有返回到
角色表的关系，该字段在这种情况下也可以为空

我将
EmployeeBase
更改为：

class EmployeeBase(db.Model):

    __tablename__ = 'employee_base'

    id = db.Column(db.Integer, primary_key=True)
    role_id = db.Column(db.Integer, db.ForeignKey('role.id'), index=True)

    given_name = db.Column(db.String(16))
    surname = db.Column(db.String(16))

    type = db.Column(db.String(50), index=True)

    __mapper_args__ = {
        'polymorphic_identity': 'employee',
        'polymorphic_on': type
    }

并从所有其他员工模型中删除了
role\u id
列定义

db.create_all()

petrolium_engineer = Role(name='Petrolium Engineer')
geotech_engineer = Role(name='Geotech Engineer')
analyst_petrolium = Role(name='Analyst of Petrolium')

db.session.add(petrolium_engineer)
db.session.add(geotech_engineer)
db.session.add(analyst_petrolium)

db.session.add(
    Intern(given_name='Joe', surname='Blogs', term_ends=datetime.now())
)
db.session.add(
    Engineer(given_name='Mark', surname='Fume', role=petrolium_engineer)
)
db.session.add(
    Engineer(given_name='Steve', surname='Rocks', role=geotech_engineer)
)
db.session.add(
    Analyst(given_name='Cindy', surname='Booker', role=analyst_petrolium)
)

db.session.commit()

petrolium_roles = db.session.query(EmployeeBase).join(Role).\
                    filter(Role.name.contains('Petrolium')).all()

for emp in petrolium_roles:
    print(f'{emp.given_name} {emp.surname} is {emp.role.name}')

# Mark Fume is Petrolium Engineer
# Cindy Booker is Analyst of Petrolium

您可以尝试显式指定join ON子句，因为第一个查询的问题似乎是
Role
仅在
analyst.Role\u id
列上加入：

employee_role_join = with_polymorphic(EmployeeBase, [Engineer, Analyst])
results = session.query(employee_role_join).join(Role).filter(Role.name.ilike('%petroleum%'))
print(str(results))

SELECT employee_base.id AS employee_base_id,
    employee_base.some_attr AS employee_base_some_attr,
    employee_base.another_attr AS employee_base_another_attr,
    employee_base.type AS employee_base_type,
    engineer.id AS engineer_id,
    engineer.role_id AS engineer_role_id,
    analyst.id AS analyst_id,
    analyst.role_id AS analyst_role_id
FROM employee_base
LEFT OUTER JOIN engineer ON employee_base.id = engineer.id
LEFT OUTER JOIN analyst ON employee_base.id = analyst.id
JOIN role ON role.id = analyst.role_id 
WHERE lower(role.name) LIKE lower(?)

employee\u role\u join
是一个
别名类
，它同时公开
分析师
和
工程师
，然后我们可以使用它创建一个join ON子句，如下所示：

results = session.query(employee_role_join)\
        .join(Role, or_(  \
            employee_role_join.Engineer.role_id==Role.id,  \
            employee_role_join.Analyst.role_id==Role.id  \
        ))\
        .filter(Role.name.ilike('%petroleum%'))

这会将生成的SQL更改为engineer.role\u id=role.id或analyst.role\u id=role.id上的JOIN role，这对于示例案例来说是一个可靠的解决方案，但对于我类似的实际情况，这是不可能的。您不能更改模式吗？不，这是一个基于真实场景的人为简化示例。现实世界中的模式要复杂得多，无法更改。这有点超出我的理解，但我很想知道答案。您是否尝试过向邮件列表发送邮件？解释得很好。非常感谢。