如何使用在 SQLAlchemy 和 contains_eager 关系上定义的 order_by？

Question

The Zen of Joined Eager Loading docs recommends using contains_eager() if we want to keep the relationship order defined in the model.

"If we wanted to use just one JOIN for collection loading as well as ordering, we use the contains_eager() option, described in Routing Explicit Joins/Statements into Eagerly Loaded Collections below."

But the following example seems to behave otherwise. I must be missing something, but unsure what.

class Parent(Base):
    __tablename__ = "parent"

    parent_id = Column(types.Integer, primary_key=True)
    name = Column(types.String(200), nullable=False)


class Child(Base):
    __tablename__ = "child"

    order = Column(types.Integer, default=0)
    name = Column(types.String(200))

    parent_id = Column(types.Integer, ForeignKey(Parent.parent_id))
    parent = relationship(
        Parent,
        backref=backref(
            "children",
            cascade="all,delete",
            order_by="Child.order",
        ),
    )

query = session.query(Parent).options(
    contains_eager(Parent.children)
).filter(Parent.parent_id == 99).filter(Child.name == "foo")

Generates the following SQL:

SELECT parent.parent_id, parent.name,
       child.order, child.name,
FROM parent, child
WHERE parent.parent_id = 99 AND parent.name = 'foo'

For some reason,

ORDER BY child.order

is missing, even though it's defined in the relationship() . Any hints?

It works fine if the order_by is specified at query time, but I want to avoid writing the same ordering criteria multiple times.

Answer 1

The documentation is correct, and it refers to the fact that if using most out-of-the box eager loading methods, the query is modified and might not be optimal.

The suggestion is then to use contains_eager where:

1) the user is responsible for constructing the correct query (including joins, filters, ordering etc)

2) by using contains_eager the user hints SA that the specified relationship is included in the query.

---

The way to load relationship eagerly would be to use joinedload :

q_joined = (
    session
    .query(Parent)
    .options(joinedload(Parent.children))
    .filter(Parent.parent_id == parent_id)
)

But you cannot apply these additional filters in this case.

Using the contains_eager you would do:

q_manual = (
    session
    .query(Parent)
    .join(Child)  # MUST HAVE THIS
    .options(contains_eager(Parent.children))
    .filter(Parent.parent_id == 99)
    # .filter(Child.name == "foo")  # you can add this, but you are "tricking" SA into believing that only these 'Child' are part of the Parent.children relationship.
    .order_by(Parent.parent_id, Child.order)  # JUST ADD THIS to solve the ordering
)