This is an automated email from the ASF dual-hosted git repository.

morrySnow pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git


The following commit(s) were added to refs/heads/master by this push:
     new 0a6b84b5a88 [fix](lambda) Preserve lambda slots in outer join 
projection rewrites (#70627)
0a6b84b5a88 is described below

commit 0a6b84b5a88b85f1cb5568b076bafe6ca7b01011
Author: morrySnow <[email protected]>
AuthorDate: Fri Nov 20 15:43:01 2026 +0800

    [fix](lambda) Preserve lambda slots in outer join projection rewrites 
(#70627)
    
    ### Background
    
    Project-aware join reordering normalizes projections before moving
    expressions across joins. Outer joins require child slots to retain
    their pre-join nullability.
    
    ### What problem does this PR solve?
    
    Issue Number: close #70447
    Related PR: #67541 (introduced the shared helper)
    
    Problem Summary: Lambda projections over outer joins can fail during
    planning. Preserve lambda-local slots while adjusting input slot
    nullability.
    
    ### Details
    
    - **Frequency:** When join exploration normalizes a matching outer-join
    projection containing a lambda argument.
    - **Root cause:** The rewrite looks up every slot in join child outputs,
    including lambda arguments that are not child outputs.
    - **Why existing tests missed it:** Projection normalization tests did
    not include lambda-local slots.
    - **Fix:** Leave slots marked as not originating from children unchanged
    while retaining ordinary child slot replacement.
    - **Other paths and branches:** The shared helper is used by multiple
    project-aware join reorder rules; release branches need separate
    consideration.
    
    ### Release note
    
    Fix planning failures for lambda projections above outer joins during
    join reordering.
---
 .../exploration/join/ProjectJoinReorderHelper.java |  4 +++-
 .../join/ProjectJoinReorderHelperTest.java         | 26 ++++++++++++++++++++++
 2 files changed, 29 insertions(+), 1 deletion(-)

diff --git 
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/ProjectJoinReorderHelper.java
 
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/ProjectJoinReorderHelper.java
index 28113b32617..272b1ee1704 100644
--- 
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/ProjectJoinReorderHelper.java
+++ 
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/ProjectJoinReorderHelper.java
@@ -21,6 +21,7 @@ import org.apache.doris.nereids.rules.exploration.CBOUtils;
 import org.apache.doris.nereids.trees.expressions.ExprId;
 import org.apache.doris.nereids.trees.expressions.NamedExpression;
 import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.expressions.SlotNotFromChildren;
 import org.apache.doris.nereids.trees.plans.JoinType;
 import org.apache.doris.nereids.trees.plans.Plan;
 import org.apache.doris.nereids.trees.plans.logical.LogicalJoin;
@@ -175,7 +176,8 @@ final class ProjectJoinReorderHelper {
         });
         return project.getProjects().stream()
                 .map(expression -> expression.rewriteUp(child ->
-                        child instanceof Slot ? childSlots.get((Slot) child) : 
child))
+                        child instanceof Slot && !(child instanceof 
SlotNotFromChildren)
+                                ? childSlots.get((Slot) child) : child))
                 .map(NamedExpression.class::cast)
                 .collect(Collectors.toList());
     }
diff --git 
a/fe/fe-core/src/test/java/org/apache/doris/nereids/rules/exploration/join/ProjectJoinReorderHelperTest.java
 
b/fe/fe-core/src/test/java/org/apache/doris/nereids/rules/exploration/join/ProjectJoinReorderHelperTest.java
index 137a146166e..179f62e4324 100644
--- 
a/fe/fe-core/src/test/java/org/apache/doris/nereids/rules/exploration/join/ProjectJoinReorderHelperTest.java
+++ 
b/fe/fe-core/src/test/java/org/apache/doris/nereids/rules/exploration/join/ProjectJoinReorderHelperTest.java
@@ -23,9 +23,13 @@ import org.apache.doris.nereids.rules.RuleSet;
 import org.apache.doris.nereids.rules.RuleType;
 import org.apache.doris.nereids.trees.expressions.Add;
 import org.apache.doris.nereids.trees.expressions.Alias;
+import org.apache.doris.nereids.trees.expressions.ArrayItemReference;
 import org.apache.doris.nereids.trees.expressions.NamedExpression;
 import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.expressions.functions.scalar.ArrayMap;
+import org.apache.doris.nereids.trees.expressions.functions.scalar.Lambda;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.Random;
+import org.apache.doris.nereids.trees.expressions.literal.ArrayLiteral;
 import org.apache.doris.nereids.trees.expressions.literal.IntegerLiteral;
 import org.apache.doris.nereids.trees.plans.JoinType;
 import org.apache.doris.nereids.trees.plans.Plan;
@@ -145,6 +149,28 @@ class ProjectJoinReorderHelperTest {
         
Assertions.assertTrue(ProjectJoinReorderHelper.normalize(fullOuterProject).isEmpty());
     }
 
+    @Test
+    void preserveLambdaArgumentsAcrossOuterJoin() {
+        ArrayItemReference item = new ArrayItemReference("x",
+                new ArrayLiteral(ImmutableList.of(new IntegerLiteral(0))));
+        Lambda lambda = new Lambda(ImmutableList.of("x"),
+                new Add(item.toSlot(), left.getOutput().get(1)), 
ImmutableList.of(item));
+        Alias alias = new Alias(new ArrayMap(lambda), "mapped");
+
+        LogicalJoin<LogicalPlan, LogicalPlan> leftOuter = 
join(JoinType.LEFT_OUTER_JOIN);
+        LogicalProject<LogicalJoin<LogicalPlan, LogicalPlan>> project
+                = new LogicalProject<>(ImmutableList.of(alias), leftOuter);
+        LogicalProject<LogicalJoin<Plan, Plan>> normalized
+                = ProjectJoinReorderHelper.normalize(project).orElseThrow();
+        assertInputProject(normalized.child().left(), alias, 
left.getOutput().get(0));
+        Assertions.assertEquals(outputSignature(project), 
outputSignature(normalized));
+
+        LogicalJoin<LogicalPlan, LogicalPlan> rightOuter = 
join(JoinType.RIGHT_OUTER_JOIN);
+        LogicalProject<LogicalJoin<LogicalPlan, LogicalPlan>> nullableProject
+                = new LogicalProject<>(ImmutableList.of(alias), rightOuter);
+        
Assertions.assertTrue(ProjectJoinReorderHelper.normalize(nullableProject).isEmpty());
+    }
+
     @Test
     void pushLeftSemiProjectAndRejectMarkJoin() {
         LogicalJoin<LogicalPlan, LogicalPlan> semiJoin = 
join(JoinType.LEFT_SEMI_JOIN);


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to