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

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


The following commit(s) were added to refs/heads/master by this push:
     new f9c7dd317cf HIVE-30146: Prevent outer join input swapping in semi-join 
rule (#6885)
f9c7dd317cf is described below

commit f9c7dd317cff9eb3cee087a9347c435a06937c91
Author: Ryu Kobayashi <[email protected]>
AuthorDate: Sat Oct 24 03:28:16 2026 +0900

    HIVE-30146: Prevent outer join input swapping in semi-join rule (#6885)
---
 .../optimizer/calcite/rules/HiveSemiJoinRule.java  |   4 +
 .../calcite/rules/TestHiveSemiJoinRule.java        | 167 +++++++++++++++++++++
 .../clientpositive/cbo_left_join_aggregate.q       |  34 +++++
 .../llap/cbo_left_join_aggregate.q.out             |  86 +++++++++++
 4 files changed, 291 insertions(+)

diff --git 
a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveSemiJoinRule.java
 
b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveSemiJoinRule.java
index 36c843a6157..059ed7176d5 100644
--- 
a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveSemiJoinRule.java
+++ 
b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveSemiJoinRule.java
@@ -293,6 +293,10 @@ public void onMatch(RelOptRuleCall call) {
         return;
       }
 
+      if (join.getJoinType() != JoinRelType.INNER) {
+        return;
+      }
+
       final Aggregate aggregate = call.rel(2);
       final RelNode aggregateInput = call.rel(3);
       final RelNode right = call.rel(4);
diff --git 
a/ql/src/test/org/apache/hadoop/hive/ql/optimizer/calcite/rules/TestHiveSemiJoinRule.java
 
b/ql/src/test/org/apache/hadoop/hive/ql/optimizer/calcite/rules/TestHiveSemiJoinRule.java
new file mode 100644
index 00000000000..23f9a5f4aa1
--- /dev/null
+++ 
b/ql/src/test/org/apache/hadoop/hive/ql/optimizer/calcite/rules/TestHiveSemiJoinRule.java
@@ -0,0 +1,167 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.hadoop.hive.ql.optimizer.calcite.rules;
+
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.JoinRelType;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.tools.RelBuilder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Collections;
+
+import static 
org.apache.hadoop.hive.ql.optimizer.calcite.rules.TestRuleHelper.assertPlans;
+import static 
org.apache.hadoop.hive.ql.optimizer.calcite.rules.TestRuleHelper.buildPlanner;
+import static 
org.apache.hadoop.hive.ql.optimizer.calcite.rules.TestRuleHelper.PlanFixture;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TestHiveSemiJoinRule {
+
+  private PlanFixture fixture(RelOptRule rule) {
+    return new PlanFixture(buildPlanner(Collections.singletonList(rule)))
+        .registerTable("t1", TestHiveAntiSemiJoinRule.T1Record.class)
+        .registerTable("t2", TestHiveAntiSemiJoinRule.T2Record.class);
+  }
+
+  @Test
+  public void testProjectLeftJoinWithAggregateOnLeftIsNotRewritten() {
+    PlanFixture fixture = fixture(HiveSemiJoinRule.INSTANCE_PROJECT_SWAPPED);
+    RelBuilder builder = buildJoinPlan(fixture, JoinRelType.LEFT);
+    RelNode plan = builder.project(builder.field("t2id")).build();
+
+    assertUnchanged(fixture, plan);
+  }
+
+  @Test
+  public void testAggregateLeftJoinWithAggregateOnLeftIsNotRewritten() {
+    PlanFixture fixture = fixture(HiveSemiJoinRule.INSTANCE_AGGREGATE_SWAPPED);
+    RelBuilder builder = buildJoinPlan(fixture, JoinRelType.LEFT);
+    RelNode plan = builder
+        .aggregate(builder.groupKey(), 
builder.aggregateCall(SqlStdOperatorTable.COUNT))
+        .build();
+
+    assertUnchanged(fixture, plan);
+  }
+
+  @Test
+  public void testProjectOuterJoinWithAggregateOnLeftIsNotRewritten() {
+    for (JoinRelType joinType : new JoinRelType[] {JoinRelType.RIGHT, 
JoinRelType.FULL}) {
+      PlanFixture fixture = fixture(HiveSemiJoinRule.INSTANCE_PROJECT_SWAPPED);
+      RelBuilder builder = buildJoinPlan(fixture, joinType);
+      RelNode plan = builder.project(builder.field("t2id")).build();
+
+      assertUnchanged(fixture, plan);
+    }
+  }
+
+  @Test
+  public void testAggregateOuterJoinWithAggregateOnLeftIsNotRewritten() {
+    for (JoinRelType joinType : new JoinRelType[] {JoinRelType.RIGHT, 
JoinRelType.FULL}) {
+      PlanFixture fixture = 
fixture(HiveSemiJoinRule.INSTANCE_AGGREGATE_SWAPPED);
+      RelBuilder builder = buildJoinPlan(fixture, joinType);
+      RelNode plan = builder
+          .aggregate(builder.groupKey(), 
builder.aggregateCall(SqlStdOperatorTable.COUNT))
+          .build();
+
+      assertUnchanged(fixture, plan);
+    }
+  }
+
+  @Test
+  public void testProjectOuterJoinWithAggregateOnRightIsNotRewritten() {
+    for (JoinRelType joinType : new JoinRelType[] {JoinRelType.RIGHT, 
JoinRelType.FULL}) {
+      PlanFixture fixture = fixture(HiveSemiJoinRule.INSTANCE_PROJECT);
+      RelBuilder builder = buildJoinPlanWithAggregateOnRight(fixture, 
joinType);
+      RelNode plan = builder.project(builder.field("t1id")).build();
+
+      assertUnchanged(fixture, plan);
+    }
+  }
+
+  @Test
+  public void testAggregateOuterJoinWithAggregateOnRightIsNotRewritten() {
+    for (JoinRelType joinType : new JoinRelType[] {JoinRelType.RIGHT, 
JoinRelType.FULL}) {
+      PlanFixture fixture = fixture(HiveSemiJoinRule.INSTANCE_AGGREGATE);
+      RelBuilder builder = buildJoinPlanWithAggregateOnRight(fixture, 
joinType);
+      RelNode plan = builder
+          .aggregate(builder.groupKey(), 
builder.aggregateCall(SqlStdOperatorTable.COUNT))
+          .build();
+
+      assertUnchanged(fixture, plan);
+    }
+  }
+
+  @Test
+  public void testProjectInnerJoinWithAggregateOnLeftIsRewritten() {
+    PlanFixture fixture = fixture(HiveSemiJoinRule.INSTANCE_PROJECT_SWAPPED);
+    RelBuilder builder = buildJoinPlan(fixture, JoinRelType.INNER);
+    RelNode plan = builder.project(builder.field("t2id")).build();
+
+    String expectedPrePlan = """
+        HiveProject(t2id=[$1])
+          HiveJoin(condition=[=($0, $1)], joinType=[inner], algorithm=[none], 
cost=[not available])
+            HiveAggregate(group=[{0}])
+              LogicalTableScan(table=[[t1]])
+            LogicalTableScan(table=[[t2]])
+        """;
+
+    String expectedPostPlan = """
+        HiveSemiJoin(condition=[=($0, $1)], joinType=[semi])
+          HiveProject(t2id=[$0])
+            LogicalTableScan(table=[[t2]])
+          HiveProject(t1id=[$0])
+            LogicalTableScan(table=[[t1]])
+        """;
+
+    assertPlans(fixture.getPlanner(), plan, expectedPrePlan, expectedPostPlan);
+  }
+
+  private RelBuilder buildJoinPlan(PlanFixture fixture, JoinRelType joinType) {
+    RelBuilder builder = fixture.createRelBuilder();
+    return builder
+        .scan("t1")
+        .aggregate(builder.groupKey(0))
+        .scan("t2")
+        .join(joinType, builder.equals(
+            builder.field(2, 0, "t1id"),
+            builder.field(2, 1, "t2id")));
+  }
+
+  private RelBuilder buildJoinPlanWithAggregateOnRight(PlanFixture fixture, 
JoinRelType joinType) {
+    RelBuilder builder = fixture.createRelBuilder();
+    return builder
+        .scan("t1")
+        .scan("t2")
+        .aggregate(builder.groupKey(0))
+        .join(joinType, builder.equals(
+            builder.field(2, 0, "t1id"),
+            builder.field(2, 1, "t2id")));
+  }
+
+  private void assertUnchanged(PlanFixture fixture, RelNode plan) {
+    String expectedPlan = RelOptUtil.toString(plan);
+    assertPlans(fixture.getPlanner(), plan, expectedPlan, expectedPlan);
+  }
+
+  // Record classes are shared with TestHiveAntiSemiJoinRule.
+}
diff --git a/ql/src/test/queries/clientpositive/cbo_left_join_aggregate.q 
b/ql/src/test/queries/clientpositive/cbo_left_join_aggregate.q
new file mode 100644
index 00000000000..cd2cdd2718c
--- /dev/null
+++ b/ql/src/test/queries/clientpositive/cbo_left_join_aggregate.q
@@ -0,0 +1,34 @@
+
+-- SORT_QUERY_RESULTS
+
+with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select count(*)
+from (select distinct k from t1) a
+left join t2 b on a.k = b.k;
+
+with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select b.k
+from (select distinct k from t1) a
+left join t2 b on a.k = b.k;
+
+with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select count(*)
+from (select distinct k from t1) a
+right join t2 b on a.k = b.k;
+
+with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select count(*)
+from (select distinct k from t1) a
+full join t2 b on a.k = b.k;
diff --git 
a/ql/src/test/results/clientpositive/llap/cbo_left_join_aggregate.q.out 
b/ql/src/test/results/clientpositive/llap/cbo_left_join_aggregate.q.out
new file mode 100644
index 00000000000..42da7b5f8fb
--- /dev/null
+++ b/ql/src/test/results/clientpositive/llap/cbo_left_join_aggregate.q.out
@@ -0,0 +1,86 @@
+PREHOOK: query: with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select count(*)
+from (select distinct k from t1) a
+left join t2 b on a.k = b.k
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+#### A masked pattern was here ####
+POSTHOOK: query: with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select count(*)
+from (select distinct k from t1) a
+left join t2 b on a.k = b.k
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+#### A masked pattern was here ####
+3
+PREHOOK: query: with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select b.k
+from (select distinct k from t1) a
+left join t2 b on a.k = b.k
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+#### A masked pattern was here ####
+POSTHOOK: query: with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select b.k
+from (select distinct k from t1) a
+left join t2 b on a.k = b.k
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+#### A masked pattern was here ####
+1
+1
+NULL
+PREHOOK: query: with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select count(*)
+from (select distinct k from t1) a
+right join t2 b on a.k = b.k
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+#### A masked pattern was here ####
+POSTHOOK: query: with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select count(*)
+from (select distinct k from t1) a
+right join t2 b on a.k = b.k
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+#### A masked pattern was here ####
+4
+PREHOOK: query: with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select count(*)
+from (select distinct k from t1) a
+full join t2 b on a.k = b.k
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+#### A masked pattern was here ####
+POSTHOOK: query: with t1 as
+  (select stack(3, 1, 1, 2) as (k)),
+ t2 as
+  (select stack(4, 1, 1, 3, 4) as (k))
+select count(*)
+from (select distinct k from t1) a
+full join t2 b on a.k = b.k
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+#### A masked pattern was here ####
+5

Reply via email to