Python 在SQLAlchemy/Flask中连接多个表

我试图在SQLAlchemy中找到正确的连接查询设置，但我似乎无法理解它

我有以下表格设置（简化，我省略了非必要字段）：

因此，关系如下：

• 1:n组成员
• 1:n成员项目
• 1:n版本项

我想通过从数据库中选择具有特定版本的所有项行来构造一个查询。然后我想按组再按成员点。使用Flask/WTForm的输出应如下所示：

* GroupA
  * MemberA
     * ItemA (version = selected by user)
     * ItemB ( dito )
  * Member B
     * ItemC ( dito )
  ....

我提出了如下查询，但我确信它是不正确的（而且效率低下）

我的第一个直觉方法是创建

Item.query.join(Member, Item.member==Member.id)
    .filter(Member.versions.name=='MySelection')
    .order_by(Member.number).order_by(Group.number)

---

但显然，这根本不起作用。Version表上的join操作似乎没有在两个表之间生成我所期望的连接类型。也许我完全误解了这个概念，但在阅读了教程之后，这对我来说是有意义的。

以下内容将在一个查询中为您提供所需的对象：

q = (session.query(Group, Member, Item, Version)
        .join(Member)
        .join(Item)
        .join(Version)
        .filter(Version.name == my_version)
        .order_by(Group.number)
        .order_by(Member.number)
        ).all()
print_tree(q)

但是，您将得到一个元组列表

（组、成员、项、版本）

。现在，由您以树的形式显示它。但下面的代码可能很有用：

def print_tree(rows):
    def get_level_diff(row1, row2):
        """ Returns tuple: (from, to) of different item positions.  """
        if row1 is None: # first row handling
            return (0, len(row2))
        assert len(row1) == len(row2)
        for col in range(len(row1)):
            if row1[col] != row2[col]:
                return (col, len(row2))
        assert False, "should not have duplicates"

    prev_row = None
    for row in rows:
        level = get_level_diff(prev_row, row)
        for l in range(*level):
            print 2 * l * " ", row[l]
            prev_row = row

Update-1:如果您愿意放弃前两个关系的

lazy='dynamic'

，您可以使用以下代码通过查询加载整个

对象网络（与上面的元组相反）：

q = (session.query(Group)
        .join(Member)
        .join(Item)
        .join(Version)
        # @note: here we are tricking sqlalchemy to think that we loaded all these relationships,
        # even though we filter them out by version. Please use this only to get data and display,
        # but not to continue working with it as if it were a regular UnitOfWork
        .options(
            contains_eager(Group.member).
            contains_eager(Member.items).
            contains_eager(Item.version)
            )
        .filter(Version.name == my_version)
        .order_by(Group.number)
        .order_by(Member.number)
        ).all()

# print tree: easy navigation of relationships
for g in q:
    print "", g
    for m in g.member:
        print 2 * " ", m
        for i in m.items:
            print 4 * " ", i

非常感谢。我已经进行了实验，并提出了一个与您的解决方案非常相似的查询。我只是觉得它看起来并不优雅，因为我在类定义中定义了所有表之间的关系。打印树代码很棒！我知道有一种更简单的方法可以得到你想要的东西，但它不适用于
lazy='dynamic'
关系。这是你坚持要吃的东西吗？
def print_tree(rows):
    def get_level_diff(row1, row2):
        """ Returns tuple: (from, to) of different item positions.  """
        if row1 is None: # first row handling
            return (0, len(row2))
        assert len(row1) == len(row2)
        for col in range(len(row1)):
            if row1[col] != row2[col]:
                return (col, len(row2))
        assert False, "should not have duplicates"

    prev_row = None
    for row in rows:
        level = get_level_diff(prev_row, row)
        for l in range(*level):
            print 2 * l * " ", row[l]
            prev_row = row

q = (session.query(Group)
        .join(Member)
        .join(Item)
        .join(Version)
        # @note: here we are tricking sqlalchemy to think that we loaded all these relationships,
        # even though we filter them out by version. Please use this only to get data and display,
        # but not to continue working with it as if it were a regular UnitOfWork
        .options(
            contains_eager(Group.member).
            contains_eager(Member.items).
            contains_eager(Item.version)
            )
        .filter(Version.name == my_version)
        .order_by(Group.number)
        .order_by(Member.number)
        ).all()

# print tree: easy navigation of relationships
for g in q:
    print "", g
    for m in g.member:
        print 2 * " ", m
        for i in m.items:
            print 4 * " ", i