Collapse repeated prefetch lookups on the optimizer path (v0.19.1).

An interface query carries a sibling fragment per implementing type, so the
same field is walked more than once and each pass builds its own queryset.
Django compares prefetch querysets by identity and rejects a repeated target,
which surfaced as "'x' lookup was already seen with a different queryset".

The collapse existed but only ran when loading relations onto rows already in
hand, not when building the query. It went unnoticed because duplicates were
previously bare paths, which Django tolerates; on= made them carry a queryset,
which it does not.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: jamietdavidson

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "strawberry-orm"
-version = "0.19.0"
+version = "0.19.1"
 description = "Unified, backend-agnostic ORM abstraction for Strawberry GraphQL"
 readme = "README.md"
 license = "MIT"

src/strawberry_orm/backends/django.py

@@ -1048,10 +1048,18 @@ def optimize() -> Any:
             select_related, prefetch_related = self._relation_lookups(
                 store, model, info
             )
+            # One relation can be reached twice - two aliases, or the same
+            # field under sibling fragments of an interface - and each pass
+            # builds its own queryset. Django compares those by identity, so
+            # duplicates have to be collapsed before they reach it.
             if select_related:
-                optimized_query = optimized_query.select_related(*select_related)
+                optimized_query = optimized_query.select_related(
+                    *_dedupe_lookups(select_related)
+                )
             if prefetch_related:
-                optimized_query = optimized_query.prefetch_related(*prefetch_related)
+                optimized_query = optimized_query.prefetch_related(
+                    *_dedupe_lookups(prefetch_related)
+                )
 
             return list(optimized_query)
 

tests/backends/django/test_on_duplicate_lookups.py

@@ -0,0 +1,87 @@
+"""One relation reached twice must not collide in the prefetch.
+
+An interface query carries a sibling fragment per implementing type, so the
+same field is walked more than once and each pass builds its own queryset.
+Django compares prefetch querysets by identity and rejects a repeated target,
+which surfaced as ``'x' lookup was already seen with a different queryset``.
+"""
+
+import pytest
+import strawberry
+
+from strawberry_orm import StrawberryORM
+from strawberry_orm.types import auto
+
+
+def _orm():
+    return StrawberryORM.for_django(warn_missing_scope=False, lazy_resolution="off")
+
+
+@pytest.mark.django_db
+class TestDuplicateLookups:
+    def test_the_same_on_field_under_two_fragments(self, seed, User, Post):
+        orm = _orm()
+
+        @orm.type(Post)
+        class PostType:
+            id: auto
+            title: auto
+
+        @orm.type(User)
+        class UserType:
+            id: auto
+            name: auto
+            published: list[PostType] = orm.field.eager(
+                on="posts", scope=lambda qs, info: qs.filter(is_published=True)
+            )
+
+        @strawberry.type
+        class Query:
+            users: list[UserType] = orm.field.eager()
+
+        # The field is named twice in one selection, which is what an
+        # interface's sibling fragments produce.
+        result = orm.schema(query=Query).execute_sync(
+            """
+            {
+              users {
+                published { title }
+                ... on UserType { published { title } }
+              }
+            }
+            """,
+            context_value={},
+        )
+        assert result.errors is None, result.errors
+        titles = {p["title"] for u in result.data["users"] for p in u["published"]}
+        assert "Draft Post" not in titles
+
+    def test_an_on_field_also_named_in_using(self, seed, User, Post):
+        """The optimizer reaches it twice: once selected, once as a hint."""
+        orm = _orm()
+
+        @orm.type(Post)
+        class PostType:
+            id: auto
+            title: auto
+
+        @orm.type(User)
+        class UserType:
+            id: auto
+            name: auto
+            published: list[PostType] = orm.field.eager(
+                on="posts", scope=lambda qs, info: qs.filter(is_published=True)
+            )
+
+            @orm.field.lazy(using=["posts"])
+            def post_count(self, info: strawberry.Info) -> int:
+                return len(list(self.posts.all()))
+
+        @strawberry.type
+        class Query:
+            users: list[UserType] = orm.field.eager()
+
+        result = orm.schema(query=Query).execute_sync(
+            "{ users { published { title } postCount } }", context_value={}
+        )
+        assert result.errors is None, result.errors

tests/backends/sqlalchemy/test_on_duplicate_lookups.py

@@ -0,0 +1,97 @@
+"""One relation reached twice must not collide in the prefetch.
+
+An interface query carries a sibling fragment per implementing type, so the
+same field is walked more than once and each pass builds its own queryset.
+Django compares prefetch querysets by identity and rejects a repeated target,
+which surfaced as ``'x' lookup was already seen with a different queryset``.
+"""
+
+import pytest
+import strawberry
+
+from strawberry_orm import StrawberryORM
+from strawberry_orm.types import auto
+from tests.backends.sqlalchemy.models import Post as SAPost
+from tests.backends.sqlalchemy.models import User as SAUser
+
+
+def _orm():
+    return StrawberryORM.for_sqlalchemy(
+        dialect="sqlite", warn_missing_scope=False, lazy_resolution="off"
+    )
+
+
+class TestDuplicateLookups:
+    @pytest.fixture(autouse=True)
+    def _session(self, sa_session, seed):
+        self._s = sa_session
+
+    def test_the_same_on_field_under_two_fragments(self):
+        orm = _orm()
+
+        @orm.type(SAPost)
+        class PostType:
+            id: auto
+            title: auto
+
+        @orm.type(SAUser)
+        class UserType:
+            id: auto
+            name: auto
+            published: list[PostType] = orm.field.eager(
+                on="posts",
+                scope=lambda qs, info: qs.where(SAPost.is_published.is_(True)),
+            )
+
+        @strawberry.type
+        class Query:
+            users: list[UserType] = orm.field.eager()
+
+        # The field is named twice in one selection, which is what an
+        # interface's sibling fragments produce.
+        result = orm.schema(query=Query).execute_sync(
+            """
+            {
+              users {
+                published { title }
+                ... on UserType { published { title } }
+              }
+            }
+            """,
+            context_value={"session": self._s},
+        )
+        assert result.errors is None, result.errors
+        titles = {p["title"] for u in result.data["users"] for p in u["published"]}
+        assert "Draft Post" not in titles
+
+    def test_an_on_field_also_named_in_using(self):
+        """The optimizer reaches it twice: once selected, once as a hint."""
+        orm = _orm()
+
+        @orm.type(SAPost)
+        class PostType:
+            id: auto
+            title: auto
+
+        @orm.type(SAUser)
+        class UserType:
+            id: auto
+            name: auto
+            published: list[PostType] = orm.field.eager(
+                on="posts",
+                scope=lambda qs, info: qs.where(SAPost.is_published.is_(True)),
+            )
+
+            @orm.field.lazy(using=["posts"])
+            def post_count(self, info: strawberry.Info) -> int:
+                return len(list(self.posts))
+
+        @strawberry.type
+        class Query:
+            users: list[UserType] = orm.field.eager()
+
+        result = orm.schema(query=Query).execute_sync(
+            "{ users { published { title } postCount } }",
+            context_value={"session": self._s},
+        )
+        assert result.errors is None, result.errors

tests/test_backend_parity.py

@@ -98,8 +98,10 @@
     # that rather than the behaviour the other two share.
     "test_relation_connection.py",
     # on= is refused on Tortoise, so its test_on.py asserts that rather than
-    # the behaviour the other two share.
+    # the behaviour the other two share, and the duplicate-lookup case it
+    # brings cannot arise there at all.
     "test_on.py",
+    "test_on_duplicate_lookups.py",
     "test_query_session_resolution.py",
     "test_query_queryset_detection.py",
     "test_query_async_session.py",