Skip identity dependency bindings

Signed-off-by: Alexey Orlenko's AI Agent <robot@aqrln.net>
prisma · tensordreams · Jun 5, 2026 · Jun 5, 2026 · Jun 5, 2026 · Jun 5, 2026
commit 024046117633790e71d580ba68191b2f0396b186
diff --git a/query-compiler/query-compiler/src/translate.rs b/query-compiler/query-compiler/src/translate.rs
@@ -528,36 +528,37 @@ impl<'a, 'b> NodeTranslator<'a, 'b> {
             .iter()
             .flat_map(|edge| {
                 let edge_content = self.graph.edge_content(edge);
-                let Some(QueryGraphDependency::ProjectedDataDependency(selection, _, expectation)) = edge_content
+                let Some(QueryGraphDependency::ProjectedDataDependency(selection, sink, expectation)) = edge_content
                 else {
                     return Either::Left(std::iter::empty());
                 };
 
-                let requires_unique = matches!(
-                    edge_content,
-                    Some(QueryGraphDependency::ProjectedDataDependency(_, sink, _))
-                        if sink.is_unique()
-                );
+                let requires_unique = sink.is_unique();
 
                 let source = self.graph.edge_source(edge);
 
-                let expr = Expression::Get {
-                    name: binding::node_result(source),
-                };
-                let expr = match expectation {
-                    Some(expectation) => Expression::validate_expectation(expectation, expr),
-                    None => expr,
-                };
-                let expr = if requires_unique {
-                    Expression::Unique(expr.into())
-                } else {
-                    expr
-                };
-
-                let parent_binding = std::iter::once(Binding::new(source.id(), expr));
+                let needs_parent_binding = expectation.is_some() || requires_unique;
+                let parent_binding = needs_parent_binding.then(|| {
+                    let expr = Expression::Get {
+                        name: binding::node_result(source),
+                    };
+                    let expr = match expectation {
+                        Some(expectation) => Expression::validate_expectation(expectation, expr),
+                        None => expr,
+                    };
+                    let expr = if requires_unique {
+                        Expression::Unique(expr.into())
+                    } else {
+                        expr
+                    };
+
+                    Binding::new(source.id(), expr)
+                });
+
+                let parent_bindings = parent_binding.into_iter();
 
                 if create_field_bindings {
-                    Either::Right(Either::Left(parent_binding.chain(selection.selections().map(
+                    Either::Right(Either::Left(parent_bindings.chain(selection.selections().map(
                         move |field| {
                             Binding::new(
                                 binding::projected_dependency(source, field),
@@ -572,13 +573,9 @@ impl<'a, 'b> NodeTranslator<'a, 'b> {
                         },
                     ))))
                 } else {
-                    Either::Right(Either::Right(parent_binding))
+                    Either::Right(Either::Right(parent_bindings))
                 }
             })
-            .filter(|binding| match &binding.expr {
-                Expression::Get { name, .. } => name != &binding.name,
-                _ => true,
-            })
             .collect::<Vec<_>>();
 
         // translate plucks the edges coming into node, we need to avoid accessing it afterwards