Sqlalchemy 和过滤关系

Question

从下面的代码中，我定义了这样的关系：

UnitTypeRowModel (self-referencing but only one in the doc)
  -- PlanPmDefinition (definition in the json doc)
    -- PlanPmValues (value in the json doc)

如果我在数据库表中只有一个plan_ou，则当前结果为json：

[{
    "children": [],
    "parent_id": 1,
    "id": 4
}, {
    "children": [],
    "parent_id": 2,
    "plan_pm_id": 2,
    "id": 5
    "definition": {
        "id": 2,
        "tag": 0,
        "value": {
            "plan_pm_id": 2,
            "tag": 0,
            "plan_ou": 1
        }
    }
}]

代码：

class PlanPmValues(Base):
    __tablename__ = 'plan_pm_municipal_values'

    plan_pm_id = Column(Integer, primary_key=True)
    tag = Column(Integer, primary_key=True)
    plan_ou = Column(Integer)  # Filter on this
    ...


class PlanPmDefinition(Base):
    __tablename__ = 'plan_pm_municipal_definition'

    id = Column(Integer, primary_key=True)
    tag = Column(Integer, primary_key=True) -- always 0

    value = relationship(PlanPmValues,
               primaryjoin='and_(PlanPmDefinition.id==PlanPmValues.plan_pm_id, ' +
               'PlanPmDefinition.tag==PlanPmValues.tag)',
               foreign_keys='[PlanPmValues.plan_pm_id, PlanPmValues.tag]',
               lazy='joined', uselist=False)


class UnitTypeRowModel(Base):
    __tablename__ = 'unit_type_row_model'
    __table_args__ = {'schema': base_schema}

    id = Column(Integer, primary_key=True)
    client_id = Column(Integer, ForeignKey(base_schema + '.client.id'))
    parent_id = Column(Integer, ForeignKey(base_schema + '.unit_type_row_model.id'), nullable=True)
    plan_pm_id = Column(Integer, nullable=True)

    children = relationship(
             'UnitTypeRowModel',
             lazy='joined',
             join_depth=2,
             order_by="UnitTypeRowModel.sort_order")

    definition = relationship(
             'PlanPmDefinition',
             primaryjoin='and_(PlanPmDefinition.id==UnitTypeRowModel.plan_pm_id, ' +
             'PlanPmDefinition.tag==0)',
             foreign_keys='[UnitTypeRowModel.plan_pm_id]',
             lazy='joined',
             uselist=False)

    @staticmethod
    def get_for_unit(client_id, unit_id):
        db_session = DatabaseEngine.get_session()
        row_models = db_session.query(UnitTypeRowModel).\
            filter(UnitTypeRowModel.client_id == client_id).\
            order_by(UnitTypeRowModel.sort_order)
        json = util.Serialize.serialize_to_json(row_models)
        db_session.close()
        return json

如何在方法UnitTypeRowModel.get_for_unit 中从PlanPmValues 类中过滤plan_ou？

Answer 1

您应该为此使用自定义ColumnPropery。

from sqlalchemy import select, and_
from sqlalchemy.orm import column_property

class UnitTypeRowModel(Base):

    ...

    _ou_join = and_(plan_pm_id==PlanPmDefinition.id,
                    PlanPmDefinition.tag==PlanPmValues.tag,
                    plan_pm_id==PlanPmValues.plan_pm_id)

    plan_ou = column_property(select([PlanPmValues.plan_ou],
                                     whereclause=_ou_join).as_scalar())

为了便于阅读，我将_ou_join 拆分为单独的属性。

按照您在 SQLAlchemy 代码中定义的方式，UnitTypeRowModel 和 PlanPmDefinition 之间存在多对一关系； PlanPmDefinition 和 PlanPmValues 之间存在多对一的关系。我从uselist=False 参数中推断出这两个relationship() 调用，如果您没有通过使用唯一键在数据库中强制执行，您可能会遇到一些其他错误。这意味着结果值只能返回一行，我已使用 as_scalar() 强制执行。

一般来说，您可以使用association_proxy() 处理对此类相关对象的查询。在这种情况下，这并不理想，因为您已经在 UnitTypeRowModel 和 PlanPmValues 之间拥有和关联对象 (PlanPmDefinition)；这意味着association_proxy 将允许您直接从UnitTypeRowModel 类而不是plan_ou 值处理PlanPmValue 对象。

最后，您应该始终确认您需要以 SQLAlchemy Query.filter() 的身份执行此操作——也就是说，在 SQL 服务器上执行查询和过滤——而不是在 Python 中执行通过filter()。前者需要更多时间进行编码和测试，但几乎总是更快，因为 SQL 服务器已针对它进行了优化；后者需要更少的时间来编写代码，并且实际上只会在您执行大量返回大量结果的查询时导致性能问题。我个人用 Python 写东西，然后通过 SQL 进行慢速查询。