问题描述

Question

问题描述

我正在使用sqlalchemy（v1.2）声明式，并且我有一个带有ID和标签的简单类Node。我想建立一个自引用的多对多关系，其中关联表不是数据库表，而是动态的select语句。该语句从Node的两个联合别名中选择，并返回格式为(left_id, right_id)的行，以定义关系。到目前为止，如果我通过实例对象访问关系，那么我拥有的代码将起作用，但是当我尝试按关系进行过滤时，联接就混乱了。

“经典”自指多对多关系

作为参考，让我们从Self-Referential Many-to-Many Relationship上的文档示例开始，该示例使用关联表：

node_to_node = Table(
    "node_to_node", Base.metadata,
    Column("left_node_id", Integer, ForeignKey("node.id"), primary_key=True),
    Column("right_node_id", Integer, ForeignKey("node.id"), primary_key=True)
)

class Node(Base):
    __tablename__ = 'node'
    id = Column(Integer, primary_key=True)
    label = Column(String, unique=True)
    right_nodes = relationship(
        "Node",
        secondary=node_to_node,
        primaryjoin=id == node_to_node.c.left_node_id,
        secondaryjoin=id == node_to_node.c.right_node_id,
        backref="left_nodes"
    )

    def __repr__(self):
        return "Node(id={}, Label={})".format(self.id, self.label)

通过这种关系将Node加入自身：

>>> NodeAlias = aliased(Node)
>>> print(session.query(Node).join(NodeAlias, Node.right_nodes))
SELECT node.id AS node_id, node.label AS node_label 
FROM node JOIN node_to_node AS node_to_node_1 
    ON node.id = node_to_node_1.left_node_id
JOIN node AS node_1
    ON node_1.id = node_to_node_1.right_node_id

一切都很好。

通过关联选择语句的多对多关系

作为示例，我们实现了一种关系next_two_nodes，该关系使用id+1和id+2（如果存在）将一个节点连接到两个节点。 complete code进行测试。

这是一个为“动态”关联表生成选择语句的函数：

_next_two_nodes = None
def next_two_nodes_select():
    global _next_two_nodes
    if _next_two_nodes is None:
        _leftside = aliased(Node, name="leftside")
        _rightside = aliased(Node, name="rightside")
        _next_two_nodes = select(
            [_leftside.id.label("left_node_id"),
             _rightside.id.label("right_node_id")]
        ).select_from(
            join(
                _leftside, _rightside,
                or_(
                    _leftside.id + 1 == _rightside.id,
                    _leftside.id + 2 == _rightside.id
                )
            )
        ).alias()
    return _next_two_nodes

请注意，该函数将结果缓存在全局变量中，以便后续调用始终返回相同的对象，而不使用新的别名。这是我尝试在关系中使用此select：

class Node(Base):
    __tablename__ = 'node'
    id = Column(Integer, primary_key=True)
    label = Column(String, unique=True)

    next_two_nodes = relationship(
        "Node", secondary=next_two_nodes_select,
        primaryjoin=(lambda: foreign(Node.id) 
                     == remote(next_two_nodes_select().c.left_node_id)),
        secondaryjoin=(lambda: foreign(next_two_nodes_select().c.right_node_id)
                       == remote(Node.id)),
        backref="previous_two_nodes",
        viewonly=True
    )

    def __repr__(self):
        return "Node(id={}, Label={})".format(self.id, self.label)

一些测试数据：

nodes = [
    Node(id=1, label="Node1"),
    Node(id=2, label="Node2"),
    Node(id=3, label="Node3"),
    Node(id=4, label="Node4")
]
session.add_all(nodes)
session.commit()

通过实例访问关系按预期进行：

>>> node = session.query(Node).filter_by(id=2).one()
>>> node.next_two_nodes
[Node(id=3, Label=Node3), Node(id=4, Label=Node4)]
>>> node.previous_two_nodes
[Node(id=1, Label=Node1)]

但是，对关系进行过滤不会得到预期的结果：

>>> session.query(Node).join(NodeAlias, Node.next_two_nodes).filter(NodeAlias.id == 3).all()
[Node(id=1, Label=Node1),
 Node(id=2, Label=Node2),
 Node(id=3, Label=Node3),
 Node(id=4, Label=Node4)]

我希望仅返回Node1和Node2。确实，联接的SQL语句是错误的：

>>> print(session.query(Node).join(NodeAlias, Node.next_two_nodes))
SELECT node.id AS node_id, node.label AS node_label 
FROM node JOIN (SELECT leftside.id AS left_node_id, rightside.id AS right_node_id 
    FROM node AS leftside JOIN node AS rightside
    ON leftside.id + 1 = rightside.id OR leftside.id + 2 = rightside.id) AS anon_1
ON anon_1.left_node_id = anon_1.left_node_id
JOIN node AS node_1 ON anon_1.right_node_id = node_1.id

与上面的工作示例相比，它应该代替ON anon_1.left_node_id = anon_1.left_node_id清楚地读为ON node.id = anon_1.left_node_id。我的primaryjoin似乎是错误的，但是我不知道如何连接最后一个点。

Answer 1

经过更多调试后，我发现"Clause Adaption"正在替换我的ON子句。我不确定细节，但是出于某种原因，sqlalchemy认为我是指node.id中的select而不是原始Node表中的。我发现抑制子句适应的唯一方法是选择文本形式：

select(
    [literal_column("leftside.id").label("left_node_id"),
     literal_column("rightside.id").label("right_node_id")]
)...

通过这种方式可以断开与Node的关系，并且可以按预期进行过滤。感觉就像是一个带有无法预料的副作用的hack，也许有人知道更干净的方法...

sqlalchemy以“选择”作为关联表的多对多自引用

问题描述

“经典”自指多对多关系

通过关联选择语句的多对多关系

1 个答案: