如何使 SQLAlchemy hybrid_property 选择表达式适用于选择和过滤器

Question

我一直在尝试编写一些具有混合属性的表达式，但我发现它们非常有限，我想知道我是否可以绕过这些限制。

基本上，我发现它们可以与 session.query(Model.hybrid_property) 或 session.query(Model).filter(Model.hybrid_property==x) 一起使用，但不能同时使用。

这是我的意思的一个例子，假设有两行称为value1 和value2，name 是hybrid_property。

# With as_scalar()
>>> session.query(Model).filter(Model.value=='value1').all()
[([<__main__.Model object],)]         # this is wanted
>>> session.query(Model.value).all()
[(u'value1',)]

# Without as scalar()
>>> session.query(Model).filter(Model.value=='value1').all()
[]
>>> session.query(Model.value).all()
[(u'value1',), (u'value2',)]          # this is wanted

根据是否使用as_scalar()，它会改变它的作用。有没有办法让它同时工作？

这是一些示例代码（经过编辑以显示完全不起作用的示例）：

import os
from sqlalchemy import create_engine, Column, Integer, String, select, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.orm import sessionmaker, relationship

Engine = create_engine('sqlite://')

Base = declarative_base(bind=Engine)

Session = sessionmaker(bind=Base.metadata.bind)


class ModelRelation(Base):
    __tablename__ = 'ModelRelation'
    row_id = Column(Integer, primary_key=True)
    name = Column(String(64))


class Model(Base):
    __tablename__ = 'Model'
    row_id = Column(Integer, primary_key=True)
    relation_id = Column(Integer, ForeignKey('ModelRelation.row_id'))

    relation = relationship('ModelRelation')

    @hybrid_property
    def value(self):
        return self.relation.name

    @value.expression
    def value(cls):
        return select([ModelRelation.name]).where(ModelRelation.row_id==cls.relation_id)

    @hybrid_property
    def value_scalar(self):
        return self.relation.name

    @value_scalar.expression
    def value_scalar(cls):
        return select([ModelRelation.name]).where(ModelRelation.row_id==cls.relation_id).as_scalar()


Base.metadata.create_all()

if __name__ == '__main__':
    session = Session()

    script1 = Model(relation=ModelRelation(name='value1'))
    session.add(script1)
    script2 = Model(relation=ModelRelation(name='value2'))
    session.add(script2)
    session.commit()

    print([i.value for i in session.query(Model).all()])
    print(session.query(Model.value).all())
    print(session.query(Model).filter(Model.value=='value1').all())
    print()
    print([i.value_scalar for i in session.query(Model).all()])
    print(session.query(Model.value_scalar).all())
    print(session.query(Model).filter(Model.value_scalar=='value1').all())

    session.close()

输出是：

[u'value1', u'value2']
[(u'value1',), (u'value2',)]
[]

[u'value1', u'value2']
[(u'value1',)]
[<__main__.Model object at 0x041D5C90>]

Answer 1

您看到的可变性是由于表达式返回的对象类型以及表达式的使用位置。

没有as_scalar()：

您的表达式返回一个Select 对象。

在session.query(Model.value).all() 中，您的表达式被传递给session.query()，the docs 可以接受：

一系列实体和/或 SQL 表达式。

...所以没关系。我们可以通过这个简单的查询来证明：

print(session.query(select([1])).all())  # [(1,)]

在第二个查询 session.query(Model).filter(Model.value == "value1").all() 中，您现在使用相等比较左侧的 Select，然后将该比较的结果传递给 query.filter()。 SQLAlchemy 通过重载Column 上的__eq__() 方法使用丰富的比较来比较列（like）元素，您可以自己查看：

print(Column.__eq__)  # <function ColumnOperators.__eq__ at 0x000001F851FB11F8>

但是你的表达式返回一个Select 对象：

print(Select.__eq__)  # <slot wrapper '__eq__' of 'object' objects>
# which is just the same __eq__ method that every python object has, defined on object
print(Select.__eq__ is object.__eq__)  # True

既然我们知道Select.__eq__() 方法没有被重载，那么在Select 对象和字符串之间进行任何== 比较的结果是什么？始终False。当我们将False 作为唯一过滤器传递给查询时会发生什么？：

print(session.query(Model).filter(False).all())
# SELECT "Model".row_id AS "Model_row_id", "Model".relation_id AS "Model_relation_id" FROM "Model" WHERE 0 = 1

WHERE 0 = 1 始终评估为 false，因此查询始终为空。

与as_scalar()：

来自the docs 为Select.as_scalar()：

返回这个可选的“标量”表示，可以使用 作为列表达式。

通常，选择语句在其列中只有一列 子句有资格用作标量表达式。

返回的对象是 ScalarSelect 的一个实例。

所以在这个scanario中，表达式返回一个ScalarSelect对象，可以像列一​​样对待。

首先，解决.filter(Model.value_scalar=='value1')查询行为之间的差异：

print(ScalarSelect.__eq__ is Column.__eq__)  # True

ScalarSelect 具有与Column 相同的__eq__() 实现，这意味着在Query.filter() 的上下文中，相等性测试会产生一些有意义的东西：

print(Model.value_scalar == "value1")
# (SELECT "ModelRelation".name FROM "ModelRelation", "Model" WHERE "ModelRelation".row_id = "Model".relation_id) = :param_1

因此，在这种情况下，查询会产生合理的结果。

但是，在session.query(Model.value_scalar).all() 的情况下，它只返回一个值，即使表中有两行。

这个查询生成的sql是这样的：

SELECT (SELECT "ModelRelation".name
FROM "ModelRelation", "Model"
WHERE "ModelRelation".row_id = "Model".relation_id) AS anon_1

由于ScalarSelect 被解释为一列，它本身是被选择的，而不是被从中选择的，就像在没有as_scalar() 的情况下一样。为什么SELECT (SELECT...) AS anon_1 只从查询中返回一行，这有点超出我的理解，但我可以告诉你它发生在数据库级别，不是 sqlalchemy 处理结果并且出于某种原因只返回一个。这将通过原始 dbapi 连接执行相同的查询：

with Engine.connect() as conn:
    cxn = conn.connection
    cursor = cxn.cursor()
    cursor.execute("""
        SELECT (SELECT "ModelRelation".name
        FROM "ModelRelation", "Model"
        WHERE "ModelRelation".row_id = "Model".relation_id) AS anon_1
    """)
    print(cursor.fetchall())  # [('value1',)]

因此，当表达式返回 Column 时，您似乎会得到最一致的行为。

文档中有一个关于Join Dependent Hybrid Relationships 的部分，它只使用相关对象列作为表达式值，但您需要在查询中提供连接。

如果模型是：

class Model(Base):
    __tablename__ = "Model"
    row_id = Column(Integer, primary_key=True)
    relation_id = Column(Integer, ForeignKey("ModelRelation.row_id"))

    relation = relationship("ModelRelation")

    @hybrid_property
    def value(self):
        return self.relation.name

    @value.expression
    def value(cls):
        return ModelRelation.name

此查询：session.query(Model.value).all() 呈现为

SELECT "ModelRelation".name AS "ModelRelation_name" FROM "ModelRelation"

...并按预期返回[('value1',), ('value2',)]。

但是这个查询：session.query(Model).filter(Model.value == "value1").all() 呈现为：

SELECT "Model".row_id AS "Model_row_id", "Model".relation_id AS "Model_relation_id" 
FROM "Model", "ModelRelation" 
WHERE "ModelRelation".name = ?

...但即使我们已经过滤了值，也会返回两行：[<__main__.Model object at 0x000002060369FEC8>, <__main__.Model object at 0x000002060348B108>]。

在这部分文档中，他们正在处理名为 User 和 SavingsAccount 的模型，他们说：

但是，在表达式级别，预计 User 类 将在适当的上下文中使用，以便适当的连接 到 SavingsAccount 将出现

所以如果我们查询session.query(Model).join(ModelRelation).filter(Model.value == "value1").all()，渲染的查询变成：

SELECT "Model".row_id AS "Model_row_id", "Model".relation_id AS "Model_relation_id" 
FROM "Model" JOIN "ModelRelation" 
ON "ModelRelation".row_id = "Model".relation_id 
WHERE "ModelRelation".name = ?

...并返回正确的 1 结果：[<__main__.Model object at 0x000001606F030D48>]。

文档继续描述另一个示例 Correlated Subquery Relationship Hybrid，但我发现当 select() 是查询的目标实体时，它具有与上述完全相同的限制，因为它只返回一个结果。