You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by ro...@apache.org on 2023/12/17 06:26:19 UTC

(flink) branch master updated: [FLINK-27876][table-planner] Choose the right side as build side when using default shuffle hash strategy if left size is equal with right (#19866)

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

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


The following commit(s) were added to refs/heads/master by this push:
     new f7ababa8f0b [FLINK-27876][table-planner] Choose the right side as build side when using default shuffle hash strategy if left size is equal with right (#19866)
f7ababa8f0b is described below

commit f7ababa8f0bab87267b101efe2ecc77b700c2222
Author: Xuyang <xy...@163.com>
AuthorDate: Sun Dec 17 14:26:08 2023 +0800

    [FLINK-27876][table-planner] Choose the right side as build side when using default shuffle hash strategy if left size is equal with right (#19866)
    
    [FLINK-27876][table-planner] Choose the right side as build side when using default shuffle hash strategy if left size is equal to right
---
 .../physical/batch/BatchPhysicalJoinRuleBase.scala |   2 +-
 .../apache/flink/table/api/batch/ExplainTest.xml   |  44 +-
 .../planner/plan/batch/sql/DagOptimizationTest.xml |   2 +-
 .../planner/plan/batch/sql/DeadlockBreakupTest.xml |  54 +-
 .../plan/batch/sql/ForwardHashExchangeTest.xml     |  12 +-
 .../plan/batch/sql/MultipleInputCreationTest.xml   | 700 ++++++++++-----------
 .../planner/plan/batch/sql/RemoveShuffleTest.xml   |  10 +-
 .../planner/plan/batch/sql/SetOperatorsTest.xml    |  12 +-
 .../planner/plan/batch/sql/SubplanReuseTest.xml    |  62 +-
 .../plan/batch/sql/join/JoinReorderTest.xml        | 336 +++++-----
 .../plan/batch/sql/join/SemiAntiJoinTest.xml       |  70 +--
 .../plan/batch/sql/join/ShuffledHashJoinTest.xml   |  30 +-
 .../sql/join/ShuffledHashSemiAntiJoinTest.xml      |   2 +-
 .../table/planner/plan/batch/table/JoinTest.xml    |   6 +-
 .../table/planner/plan/hint/OptionsHintTest.xml    |  92 +--
 .../plan/hints/batch/BroadcastJoinHintTest.xml     |  22 +-
 .../plan/hints/batch/NestLoopJoinHintTest.xml      |  14 +-
 .../plan/hints/batch/ShuffleHashJoinHintTest.xml   |  12 +-
 .../plan/hints/batch/ShuffleMergeJoinHintTest.xml  |  14 +-
 .../nodes/exec/operator/BatchOperatorNameTest.xml  | 220 +++----
 .../table/planner/plan/optimize/ScanReuseTest.xml  |  40 +-
 .../program/FlinkRuntimeFilterProgramTest.xml      |   4 +-
 22 files changed, 880 insertions(+), 880 deletions(-)

diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchPhysicalJoinRuleBase.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchPhysicalJoinRuleBase.scala
index 4499f3f01f9..1ac9be8857d 100644
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchPhysicalJoinRuleBase.scala
+++ b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchPhysicalJoinRuleBase.scala
@@ -248,7 +248,7 @@ trait BatchPhysicalJoinRuleBase {
       val leftIsBuild = if (leftSize == null || rightSize == null || leftSize == rightSize) {
         // use left to build hash table if leftSize or rightSize is unknown or equal size.
         // choose right to build if join is SEMI/ANTI.
-        !join.getJoinType.projectsRight
+        join.getJoinType.projectsRight
       } else {
         leftSize < rightSize
       }
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/api/batch/ExplainTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/api/batch/ExplainTest.xml
index 954aeda3b8b..478af9e6f56 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/api/batch/ExplainTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/api/batch/ExplainTest.xml
@@ -30,7 +30,7 @@ LogicalProject(a=[$0], EXPR$1=[$1], d=[$2], EXPR$10=[$3])
             +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
 
 == Optimized Physical Plan ==
-HashJoin(joinType=[InnerJoin], where=[=(a, d)], select=[a, EXPR$1, d, EXPR$10], build=[right])
+HashJoin(joinType=[InnerJoin], where=[=(a, d)], select=[a, EXPR$1, d, EXPR$10], build=[left])
 :- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1])
 :  +- Exchange(distribution=[hash[a]])
 :     +- LocalHashAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0])
@@ -43,7 +43,7 @@ HashJoin(joinType=[InnerJoin], where=[=(a, d)], select=[a, EXPR$1, d, EXPR$10],
             +- BoundedStreamScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f])
 
 == Optimized Execution Plan ==
-MultipleInput(readOrder=[1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, EXPR$1, d, EXPR$10], build=[right])\n:- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1])\n:  +- [#1] Exchange(distribution=[hash[a]])\n+- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_SUM(sum$0) AS EXPR$1])\n   +- [#2] Exchange(distribution=[hash[d]])\n])
+MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, EXPR$1, d, EXPR$10], build=[left])\n:- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1])\n:  +- [#1] Exchange(distribution=[hash[a]])\n+- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_SUM(sum$0) AS EXPR$1])\n   +- [#2] Exchange(distribution=[hash[d]])\n])
 :- Exchange(distribution=[hash[a]])
 :  +- LocalHashAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0])
 :     +- Calc(select=[a, b])
@@ -69,7 +69,7 @@ LogicalProject(a=[$0], EXPR$1=[$1], d=[$2], EXPR$10=[$3])
             +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
 
 == Optimized Physical Plan ==
-HashJoin(joinType=[InnerJoin], where=[=(a, d)], select=[a, EXPR$1, d, EXPR$10], build=[right]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
+HashJoin(joinType=[InnerJoin], where=[=(a, d)], select=[a, EXPR$1, d, EXPR$10], build=[left]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
 :- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
 :  +- Exchange(distribution=[hash[a]]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
 :     +- LocalHashAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
@@ -82,7 +82,7 @@ HashJoin(joinType=[InnerJoin], where=[=(a, d)], select=[a, EXPR$1, d, EXPR$10],
             +- BoundedStreamScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
 
 == Optimized Execution Plan ==
-MultipleInput(readOrder=[1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, EXPR$1, d, EXPR$10], build=[right])\n:- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1])\n:  +- [#1] Exchange(distribution=[hash[a]])\n+- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_SUM(sum$0) AS EXPR$1])\n   +- [#2] Exchange(distribution=[hash[d]])\n])
+MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, EXPR$1, d, EXPR$10], build=[left])\n:- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1])\n:  +- [#1] Exchange(distribution=[hash[a]])\n+- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_SUM(sum$0) AS EXPR$1])\n   +- [#2] Exchange(distribution=[hash[d]])\n])
 :- Exchange(distribution=[hash[a]])
 :  +- LocalHashAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0])
 :     +- Calc(select=[a, b])
@@ -94,7 +94,7 @@ MultipleInput(readOrder=[1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testExplainWithAgg[extended=false]">
+  <TestCase name="testExplainWithAgg[extended=true]">
     <Resource name="explain">
       <![CDATA[== Abstract Syntax Tree ==
 LogicalProject(EXPR$0=[$1])
@@ -103,12 +103,12 @@ LogicalProject(EXPR$0=[$1])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
 
 == Optimized Physical Plan ==
-Calc(select=[EXPR$0])
-+- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count1$0) AS EXPR$0])
-   +- Exchange(distribution=[hash[a]])
-      +- LocalHashAggregate(groupBy=[a], select=[a, Partial_COUNT(*) AS count1$0])
-         +- Calc(select=[a])
-            +- BoundedStreamScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
+Calc(select=[EXPR$0]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
++- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count1$0) AS EXPR$0]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
+   +- Exchange(distribution=[hash[a]]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
+      +- LocalHashAggregate(groupBy=[a], select=[a, Partial_COUNT(*) AS count1$0]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
+         +- Calc(select=[a]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
+            +- BoundedStreamScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
 
 == Optimized Execution Plan ==
 Calc(select=[EXPR$0])
@@ -120,7 +120,7 @@ Calc(select=[EXPR$0])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testExplainWithAgg[extended=true]">
+  <TestCase name="testExplainWithAgg[extended=false]">
     <Resource name="explain">
       <![CDATA[== Abstract Syntax Tree ==
 LogicalProject(EXPR$0=[$1])
@@ -129,12 +129,12 @@ LogicalProject(EXPR$0=[$1])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
 
 == Optimized Physical Plan ==
-Calc(select=[EXPR$0]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
-+- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count1$0) AS EXPR$0]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
-   +- Exchange(distribution=[hash[a]]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
-      +- LocalHashAggregate(groupBy=[a], select=[a, Partial_COUNT(*) AS count1$0]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
-         +- Calc(select=[a]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
-            +- BoundedStreamScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
+Calc(select=[EXPR$0])
++- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count1$0) AS EXPR$0])
+   +- Exchange(distribution=[hash[a]])
+      +- LocalHashAggregate(groupBy=[a], select=[a, Partial_COUNT(*) AS count1$0])
+         +- Calc(select=[a])
+            +- BoundedStreamScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
 
 == Optimized Execution Plan ==
 Calc(select=[EXPR$0])
@@ -446,28 +446,28 @@ SortLimit(orderBy=[a ASC], offset=[0], fetch=[5], global=[true])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testExplainWithTableSourceScan[extended=false]">
+  <TestCase name="testExplainWithTableSourceScan[extended=true]">
     <Resource name="explain">
       <![CDATA[== Abstract Syntax Tree ==
 LogicalProject(a=[$0], b=[$1], c=[$2])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable, source: [TestTableSource(a, b, c)]]])
 
 == Optimized Physical Plan ==
-LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
+LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable, source: [TestTableSource(a, b, c)]]], fields=[a, b, c]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
 
 == Optimized Execution Plan ==
 LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testExplainWithTableSourceScan[extended=true]">
+  <TestCase name="testExplainWithTableSourceScan[extended=false]">
     <Resource name="explain">
       <![CDATA[== Abstract Syntax Tree ==
 LogicalProject(a=[$0], b=[$1], c=[$2])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable, source: [TestTableSource(a, b, c)]]])
 
 == Optimized Physical Plan ==
-LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable, source: [TestTableSource(a, b, c)]]], fields=[a, b, c]): rowcount = , cumulative cost = {rows, cpu, io, network, memory}
+LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
 
 == Optimized Execution Plan ==
 LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DagOptimizationTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DagOptimizationTest.xml
index 2944844181a..381620b8444 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DagOptimizationTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DagOptimizationTest.xml
@@ -857,7 +857,7 @@ LegacySink(name=[`default_catalog`.`default_database`.`sink`], fields=[a, b, c,
 +- Correlate(invocation=[split($cor0.c)], correlate=[table(split($cor0.c))], select=[a,b,c,d,e,f,i,j,k,l,m,EXPR$0], rowType=[RecordType(INTEGER a, BIGINT b, VARCHAR(2147483647) c, INTEGER d, BIGINT e, VARCHAR(2147483647) f, INTEGER i, BIGINT j, INTEGER k, VARCHAR(2147483647) l, BIGINT m, VARCHAR(2147483647) EXPR$0)], joinType=[INNER])
    +- HashJoin(joinType=[InnerJoin], where=[(a = i)], select=[a, b, c, d, e, f, i, j, k, l, m], build=[left])
       :- Exchange(distribution=[hash[a]])
-      :  +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[a, b, c, d, e, f], build=[right])
+      :  +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[a, b, c, d, e, f], build=[left])
       :     :- Exchange(distribution=[hash[b]])
       :     :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
       :     +- Exchange(distribution=[hash[e]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DeadlockBreakupTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DeadlockBreakupTest.xml
index be14feb4cf6..745d53b628f 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DeadlockBreakupTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DeadlockBreakupTest.xml
@@ -33,10 +33,10 @@ LogicalIntersect(all=[false])
       <![CDATA[
 HashAggregate(isMerge=[false], groupBy=[a, b, c], select=[a, b, c])
 +- Exchange(distribution=[keep_input_as_is[hash[a, b, c]]])
-   +- HashJoin(joinType=[LeftSemiJoin], where=[(((a = a0) OR (a IS NULL AND a0 IS NULL)) AND ((b = b0) OR (b IS NULL AND b0 IS NULL)) AND ((c = c0) OR (c IS NULL AND c0 IS NULL)))], select=[a, b, c], build=[left])
-      :- Exchange(distribution=[hash[a, b, c]])
+   +- HashJoin(joinType=[LeftSemiJoin], where=[(((a = a0) OR (a IS NULL AND a0 IS NULL)) AND ((b = b0) OR (b IS NULL AND b0 IS NULL)) AND ((c = c0) OR (c IS NULL AND c0 IS NULL)))], select=[a, b, c], build=[right])
+      :- Exchange(distribution=[hash[a, b, c]], shuffle_mode=[BATCH])
       :  +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
-      +- Exchange(distribution=[hash[a, b, c]], shuffle_mode=[BATCH])
+      +- Exchange(distribution=[hash[a, b, c]])
          +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
 ]]>
     </Resource>
@@ -319,19 +319,19 @@ LogicalUnion(all=[true])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[0,2,1], members=[\nUnion(all=[true], union=[cnt1, cnt2])\n:- Calc(select=[CAST(cnt1 AS BIGINT) AS cnt1, cnt2])\n:  +- HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, cnt1, d, cnt2], build=[right])\n:     :- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count1$0) AS cnt1])(reuse_id=[1])\n:     :  +- [#3] Exchange(distribution=[hash[a]])\n:     +- [#1] HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count1$0) AS  [...]
-:- Exchange(distribution=[keep_input_as_is[hash[d]]])
-:  +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count1$0) AS cnt2])(reuse_id=[1])
-:     +- Exchange(distribution=[hash[d]])
-:        +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(*) AS count1$0])
-:           +- Calc(select=[d])
-:              +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
-:- Exchange(distribution=[hash[d]], shuffle_mode=[BATCH])
+MultipleInput(readOrder=[0,2,1], members=[\nUnion(all=[true], union=[cnt1, cnt2])\n:- Calc(select=[CAST(cnt1 AS BIGINT) AS cnt1, cnt2])\n:  +- HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, cnt1, d, cnt2], build=[left])\n:     :- [#1] HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count1$0) AS cnt1])\n:     +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count1$0) AS cnt2])(reuse_id=[1])\n:        +- [#3] Exchange(distribution=[hash [...]
+:- Exchange(distribution=[keep_input_as_is[hash[a]]])
+:  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count1$0) AS cnt1])(reuse_id=[1])
+:     +- Exchange(distribution=[hash[a]])
+:        +- LocalHashAggregate(groupBy=[a], select=[a, Partial_COUNT(*) AS count1$0])
+:           +- Calc(select=[a])
+:              +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
+:- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
 :  +- Reused(reference_id=[1])
-+- Exchange(distribution=[hash[a]])
-   +- LocalHashAggregate(groupBy=[a], select=[a, Partial_COUNT(*) AS count1$0])
-      +- Calc(select=[a])
-         +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
++- Exchange(distribution=[hash[d]])
+   +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(*) AS count1$0])
+      +- Calc(select=[d])
+         +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
 ]]>
     </Resource>
   </TestCase>
@@ -369,7 +369,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], a0=[$3], b0=[$4], c0=[$5], a1=[$6], b1=[$
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(c = c1)], select=[a, b, c, a0, b0, c0, a1, b1, c1, a00, b00, c00], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(c = c1)], select=[a, b, c, a0, b0, c0, a1, b1, c1, a00, b00, c00], build=[left])
 :- Exchange(distribution=[hash[c]])
 :  +- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, a0, b0, c0], build=[left])
 :     :- Exchange(distribution=[keep_input_as_is[hash[a]]])
@@ -416,11 +416,11 @@ LogicalProject(a=[$0], a0=[$1])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, a0], build=[right])
-:- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
+HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, a0], build=[left])
+:- Exchange(distribution=[hash[a]])
 :  +- Calc(select=[a])(reuse_id=[1])
 :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-+- Exchange(distribution=[hash[a]])
++- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
    +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -451,17 +451,17 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3], a0=[$4], b0=[$5], d0=[$6], e0=[$7
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, d, e, a0, b0, d0, e0], build=[right])
-:- Exchange(distribution=[hash[b]], shuffle_mode=[BATCH])
-:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, d, e, a0, b0, d0, e0], build=[left])
+:- Exchange(distribution=[hash[b]])
+:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[left])
 :     :- Exchange(distribution=[hash[a]])
 :     :  +- Calc(select=[a, b], where=[(a < 10)])
 :     :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])(reuse_id=[1])
 :     +- Exchange(distribution=[hash[d]])
 :        +- Calc(select=[d, e], where=[(d < 10)])
 :           +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])(reuse_id=[2])
-+- Exchange(distribution=[hash[e]])
-   +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[right])
++- Exchange(distribution=[hash[e]], shuffle_mode=[BATCH])
+   +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[left])
       :- Exchange(distribution=[hash[a]])
       :  +- Calc(select=[a, b], where=[(a > 5)])
       :     +- Reused(reference_id=[1])
@@ -539,8 +539,8 @@ LogicalProject(a=[$0], b=[$1], c=[$2], a0=[$3], b0=[$4], c0=[$5])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(c = c0)], select=[a, b, c, a0, b0, c0], build=[right])
-:- Exchange(distribution=[hash[c]], shuffle_mode=[BATCH])
+HashJoin(joinType=[InnerJoin], where=[(c = c0)], select=[a, b, c, a0, b0, c0], build=[left])
+:- Exchange(distribution=[hash[c]])
 :  +- Calc(select=[w0$o0 AS a, b, c])
 :     +- OverAggregate(partitionBy=[b], orderBy=[b ASC], window#0=[MAX(a) AS w0$o0 RANG BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], select=[a, b, c, w0$o0])
 :        +- Exchange(distribution=[forward])
@@ -551,7 +551,7 @@ HashJoin(joinType=[InnerJoin], where=[(c = c0)], select=[a, b, c, a0, b0, c0], b
 :                       +- Sort(orderBy=[b ASC])
 :                          +- Exchange(distribution=[hash[b]])
 :                             +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-+- Exchange(distribution=[hash[c]])
++- Exchange(distribution=[hash[c]], shuffle_mode=[BATCH])
    +- Calc(select=[w0$o0 AS a, b, c])
       +- OverAggregate(partitionBy=[b], orderBy=[b ASC], window#0=[MIN(a) AS w0$o0 RANG BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], select=[a, b, c, w0$o0])
          +- Exchange(distribution=[forward])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ForwardHashExchangeTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ForwardHashExchangeTest.xml
index 9947f2a9f6f..d3094ef8e6a 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ForwardHashExchangeTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ForwardHashExchangeTest.xml
@@ -134,11 +134,11 @@ LogicalProject(a=[$0], d2=[$1])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(a = d2)], select=[a, d2], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(a = d2)], select=[a, d2], build=[left])
 :- Exchange(distribution=[keep_input_as_is[hash[a]]])
 :  +- Calc(select=[a])
 :     +- Exchange(distribution=[keep_input_as_is[hash[a1]]])
-:        +- HashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a1, a], build=[right])
+:        +- HashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a1, a], build=[left])
 :           :- Exchange(distribution=[hash[a1]])
 :           :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1], metadata=[]]], fields=[a1])
 :           +- Exchange(distribution=[hash[a]])(reuse_id=[1])
@@ -146,7 +146,7 @@ HashJoin(joinType=[InnerJoin], where=[(a = d2)], select=[a, d2], build=[right])
 +- Exchange(distribution=[keep_input_as_is[hash[d2]]])
    +- Calc(select=[d2])
       +- Exchange(distribution=[keep_input_as_is[hash[a]]])
-         +- HashJoin(joinType=[InnerJoin], where=[(d2 = a)], select=[a, d2], build=[right])
+         +- HashJoin(joinType=[InnerJoin], where=[(d2 = a)], select=[a, d2], build=[left])
             :- Reused(reference_id=[1])
             +- Exchange(distribution=[hash[d2]])
                +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[d2], metadata=[]]], fields=[d2])
@@ -225,12 +225,12 @@ MultipleInput(readOrder=[1,1,0,0], members=[\nUnion(all=[true], union=[b, sd, sy
 :- Exchange(distribution=[hash[b]])
 :  +- LocalHashAggregate(groupBy=[b], select=[b, Partial_SUM(d) AS sum$0, Partial_SUM(ny) AS sum$1, Partial_SUM(nz) AS sum$2])
 :     +- Calc(select=[b, d, ny, nz])
-:        +- MultipleInput(readOrder=[0,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, ny, nz, b, d], build=[right])\n:- Calc(select=[a, ny, nz, b])\n:  +- HashJoin(joinType=[LeftOuterJoin], where=[(a = a0)], select=[a, ny, nz, a0, b], build=[right])\n:     :- [#2] MultipleInput(readOrder=[0,1,0], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a = nz)], select=[a, ny, nz], build=[right])\n:- HashJoin(joinType=[LeftOuterJoin], where=[(a = ny)], select=[a [...]
+:        +- MultipleInput(readOrder=[0,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, ny, nz, b, d], build=[right])\n:- Calc(select=[a, ny, nz, b])\n:  +- HashJoin(joinType=[LeftOuterJoin], where=[(a = a0)], select=[a, ny, nz, a0, b], build=[right])\n:     :- [#2] MultipleInput(readOrder=[0,0,1], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a = nz)], select=[a, ny, nz], build=[right])\n:- HashJoin(joinType=[LeftOuterJoin], where=[(a = ny)], select=[a [...]
 :           :- Exchange(distribution=[hash[d]])(reuse_id=[5])
 :           :  +- Calc(select=[d])
 :           :     +- Reused(reference_id=[1])
 :           :- Exchange(distribution=[keep_input_as_is[hash[a]]])
-:           :  +- MultipleInput(readOrder=[0,1,0], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a = nz)], select=[a, ny, nz], build=[right])\n:- HashJoin(joinType=[LeftOuterJoin], where=[(a = ny)], select=[a, ny], build=[right])\n:  :- [#2] Exchange(distribution=[hash[a]])\n:  +- [#3] Exchange(distribution=[hash[ny]])\n+- [#1] Exchange(distribution=[hash[nz]])\n])(reuse_id=[4])
+:           :  +- MultipleInput(readOrder=[0,0,1], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a = nz)], select=[a, ny, nz], build=[right])\n:- HashJoin(joinType=[LeftOuterJoin], where=[(a = ny)], select=[a, ny], build=[left])\n:  :- [#2] Exchange(distribution=[hash[a]])\n:  +- [#3] Exchange(distribution=[hash[ny]])\n+- [#1] Exchange(distribution=[hash[nz]])\n])(reuse_id=[4])
 :           :     :- Exchange(distribution=[hash[nz]])
 :           :     :  +- TableSourceScan(table=[[default_catalog, default_database, z, project=[nz], metadata=[]]], fields=[nz])
 :           :     :- Exchange(distribution=[hash[a]])
@@ -243,7 +243,7 @@ MultipleInput(readOrder=[1,1,0,0], members=[\nUnion(all=[true], union=[b, sd, sy
 +- Exchange(distribution=[hash[b]])
    +- LocalHashAggregate(groupBy=[b], select=[b, Partial_SUM(d) AS sum$0, Partial_SUM(ny) AS sum$1, Partial_SUM(nz) AS sum$2])
       +- Calc(select=[b, d, ny, nz])
-         +- MultipleInput(readOrder=[0,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, ny, nz, d, a0, b], build=[right])\n:- HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, ny, nz, d], build=[right])\n:  :- [#2] MultipleInput(readOrder=[0,1,0], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a = nz)], select=[a, ny, nz], build=[right])\n:- HashJoin(joinType=[LeftOuterJoin], where=[(a = ny)], select=[a, ny], build=[right])\n:  :- [#2] Exch [...]
+         +- MultipleInput(readOrder=[0,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, ny, nz, d, a0, b], build=[right])\n:- HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, ny, nz, d], build=[right])\n:  :- [#2] MultipleInput(readOrder=[0,0,1], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a = nz)], select=[a, ny, nz], build=[right])\n:- HashJoin(joinType=[LeftOuterJoin], where=[(a = ny)], select=[a, ny], build=[left])\n:  :- [#2] Excha [...]
             :- Reused(reference_id=[3])
             :- Exchange(distribution=[keep_input_as_is[hash[a]]])
             :  +- Reused(reference_id=[4])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/MultipleInputCreationTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/MultipleInputCreationTest.xml
index bae88395aab..46ed24ad97f 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/MultipleInputCreationTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/MultipleInputCreationTest.xml
@@ -109,39 +109,6 @@ MultipleInput(readOrder=[0,1,0], members=[\nNestedLoopJoin(joinType=[LeftOuterJo
 :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
 +- Exchange(distribution=[broadcast])
    +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testIncludeCalcForChainableSource[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT * FROM chainable
-  LEFT JOIN y ON chainable.a = y.d
-  LEFT JOIN t ON chainable.a = t.a
-  WHERE chainable.a > 10
-]]>
-    </Resource>
-    <Resource name="ast">
-      <![CDATA[
-LogicalProject(a=[$0], d=[$1], e=[$2], f=[$3], ny=[$4], a0=[$5], b=[$6], c=[$7])
-+- LogicalFilter(condition=[>($0, 10)])
-   +- LogicalJoin(condition=[=($0, $5)], joinType=[left])
-      :- LogicalJoin(condition=[=($0, $1)], joinType=[left])
-      :  :- LogicalTableScan(table=[[default_catalog, default_database, chainable]])
-      :  +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-      +- LogicalTableScan(table=[[default_catalog, default_database, t]])
-]]>
-    </Resource>
-    <Resource name="optimized exec plan">
-      <![CDATA[
-MultipleInput(readOrder=[0,0,1], members=[\nNestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = a0)], select=[a, d, e, f, ny, a0, b, c], build=[right])\n:- NestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, d, e, f, ny], build=[right])\n:  :- Calc(select=[a], where=[(a > 10)])\n:  :  +- [#3] BoundedStreamScan(table=[[default_catalog, default_database, chainable]], fields=[a])\n:  +- [#2] Exchange(distribution=[broadcast])\n+- [#1] Exchange(distribution=[broadcast])\n])
-:- Exchange(distribution=[broadcast])
-:  +- Calc(select=[a, b, c], where=[(a > 10)])
-:     +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
-:- Exchange(distribution=[broadcast])
-:  +- Calc(select=[d, e, f, ny], where=[(d > 10)])
-:     +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-+- BoundedStreamScan(table=[[default_catalog, default_database, chainable]], fields=[a])
 ]]>
     </Resource>
   </TestCase>
@@ -415,6 +382,46 @@ NestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, d, e, f, ny
 :     +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
 +- Exchange(distribution=[broadcast])
    +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testBasicMultipleInput[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
+    <Resource name="sql">
+      <![CDATA[
+SELECT * FROM
+  (SELECT a FROM x INNER JOIN y ON x.a = y.d) T1
+  INNER JOIN
+  (SELECT d FROM y INNER JOIN t ON y.d = t.a) T2
+  ON T1.a = T2.d
+]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(a=[$0], d=[$1])
++- LogicalJoin(condition=[=($0, $1)], joinType=[inner])
+   :- LogicalProject(a=[$0])
+   :  +- LogicalJoin(condition=[=($0, $4)], joinType=[inner])
+   :     :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+   :     +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
+   +- LogicalProject(d=[$0])
+      +- LogicalJoin(condition=[=($0, $4)], joinType=[inner])
+         :- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
+         +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+]]>
+    </Resource>
+    <Resource name="optimized exec plan">
+      <![CDATA[
+MultipleInput(readOrder=[0,1,1,2], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])\n:- Calc(select=[a])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[d])\n   +- HashJoin(joinType=[InnerJoin], where=[(d = a)], select=[d, a], build=[left])\n      :- [#2] Exchange(distribution=[hash[d]])\n      +- [#4]  [...]
+:- Exchange(distribution=[hash[a]])
+:  +- Calc(select=[a])
+:     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
+:- Exchange(distribution=[hash[d]])(reuse_id=[1])
+:  +- Calc(select=[d])
+:     +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
+:- Reused(reference_id=[1])
++- Exchange(distribution=[hash[a]])
+   +- Calc(select=[a])
+      +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
 ]]>
     </Resource>
   </TestCase>
@@ -444,7 +451,7 @@ LogicalProject(a=[$0], d=[$1])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[2,1,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])\n:- Calc(select=[a])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[d])\n   +- HashJoin(joinType=[InnerJoin], where=[(d = a)], select=[d, a], build=[right])\n      :- [#2] Exchange(distribution=[hash[d]])\n      +- [# [...]
+MultipleInput(readOrder=[0,1,1,2], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])\n:- Calc(select=[a])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[d])\n   +- HashJoin(joinType=[InnerJoin], where=[(d = a)], select=[d, a], build=[left])\n      :- [#2] Exchange(distribution=[hash[d]])\n      +- [#4]  [...]
 :- Exchange(distribution=[hash[a]])
 :  +- Calc(select=[a])
 :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
@@ -484,7 +491,7 @@ LogicalProject(a=[$0], d=[$1])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[2,1,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])\n:- Calc(select=[a])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[d])\n   +- HashJoin(joinType=[InnerJoin], where=[(d = a)], select=[d, a], build=[right])\n      :- [#2] Exchange(distribution=[hash[d]])\n      +- [# [...]
+MultipleInput(readOrder=[0,1,1,2], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])\n:- Calc(select=[a])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[d])\n   +- HashJoin(joinType=[InnerJoin], where=[(d = a)], select=[d, a], build=[left])\n      :- [#2] Exchange(distribution=[hash[d]])\n      +- [#4]  [...]
 :- Exchange(distribution=[hash[a]])
 :  +- Calc(select=[a])
 :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
@@ -526,7 +533,7 @@ LogicalUnion(all=[true])
       <![CDATA[
 Union(all=[true], union=[a, EXPR$1])
 :- Calc(select=[a, CAST((a + 1) AS BIGINT) AS EXPR$1])
-:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])
+:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])
 :     :- Exchange(distribution=[hash[a]])
 :     :  +- Calc(select=[a])
 :     :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])(reuse_id=[1])
@@ -566,7 +573,7 @@ LogicalUnion(all=[true])
       <![CDATA[
 Union(all=[true], union=[a, EXPR$1])
 :- Calc(select=[a, CAST((a + 1) AS BIGINT) AS EXPR$1])
-:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])
+:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])
 :     :- Exchange(distribution=[hash[a]])
 :     :  +- Calc(select=[a])
 :     :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])(reuse_id=[1])
@@ -606,7 +613,7 @@ LogicalUnion(all=[true])
       <![CDATA[
 Union(all=[true], union=[a, EXPR$1])
 :- Calc(select=[a, CAST((a + 1) AS BIGINT) AS EXPR$1])
-:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])
+:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])
 :     :- Exchange(distribution=[hash[a]])
 :     :  +- Calc(select=[a])
 :     :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])(reuse_id=[1])
@@ -729,73 +736,36 @@ Calc(select=[a, b, a0, b0, c, nx, k, CAST(0 AS BIGINT) AS v])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testNoPriorityConstraint[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT * FROM x
-  INNER JOIN y ON x.a = y.d
-  INNER JOIN t ON x.a = t.a
-]]>
-    </Resource>
-    <Resource name="ast">
-      <![CDATA[
-LogicalProject(a=[$0], b=[$1], c=[$2], nx=[$3], d=[$4], e=[$5], f=[$6], ny=[$7], a0=[$8], b0=[$9], c0=[$10])
-+- LogicalJoin(condition=[=($0, $8)], joinType=[inner])
-   :- LogicalJoin(condition=[=($0, $4)], joinType=[inner])
-   :  :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
-   :  +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-   +- LogicalTableScan(table=[[default_catalog, default_database, t]])
-]]>
-    </Resource>
-    <Resource name="optimized exec plan">
-      <![CDATA[
-MultipleInput(members=[\nSortMergeJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, nx, d, e, f, ny, a0, b0, c0])\n:- SortMergeJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, nx, d, e, f, ny])\n:  :- [#2] Exchange(distribution=[hash[a]])\n:  +- [#3] Exchange(distribution=[hash[d]])\n+- [#1] Exchange(distribution=[hash[a]])\n])
-:- Exchange(distribution=[hash[a]])
-:  +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
-:- Exchange(distribution=[hash[a]])
-:  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
-+- Exchange(distribution=[hash[d]])
-   +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testBasicMultipleInput[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
+  <TestCase name="testIncludeCalcForChainableSource[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
     <Resource name="sql">
       <![CDATA[
-SELECT * FROM
-  (SELECT a FROM x INNER JOIN y ON x.a = y.d) T1
-  INNER JOIN
-  (SELECT d FROM y INNER JOIN t ON y.d = t.a) T2
-  ON T1.a = T2.d
+SELECT * FROM chainable
+  LEFT JOIN y ON chainable.a = y.d
+  LEFT JOIN t ON chainable.a = t.a
+  WHERE chainable.a > 10
 ]]>
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(a=[$0], d=[$1])
-+- LogicalJoin(condition=[=($0, $1)], joinType=[inner])
-   :- LogicalProject(a=[$0])
-   :  +- LogicalJoin(condition=[=($0, $4)], joinType=[inner])
-   :     :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
-   :     +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-   +- LogicalProject(d=[$0])
-      +- LogicalJoin(condition=[=($0, $4)], joinType=[inner])
-         :- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-         +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+LogicalProject(a=[$0], d=[$1], e=[$2], f=[$3], ny=[$4], a0=[$5], b=[$6], c=[$7])
++- LogicalFilter(condition=[>($0, 10)])
+   +- LogicalJoin(condition=[=($0, $5)], joinType=[left])
+      :- LogicalJoin(condition=[=($0, $1)], joinType=[left])
+      :  :- LogicalTableScan(table=[[default_catalog, default_database, chainable]])
+      :  +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
+      +- LogicalTableScan(table=[[default_catalog, default_database, t]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[2,1,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])\n:- Calc(select=[a])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[d])\n   +- HashJoin(joinType=[InnerJoin], where=[(d = a)], select=[d, a], build=[right])\n      :- [#2] Exchange(distribution=[hash[d]])\n      +- [# [...]
-:- Exchange(distribution=[hash[a]])
-:  +- Calc(select=[a])
-:     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
-:- Exchange(distribution=[hash[d]])(reuse_id=[1])
-:  +- Calc(select=[d])
+MultipleInput(readOrder=[0,0,1], members=[\nNestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = a0)], select=[a, d, e, f, ny, a0, b, c], build=[right])\n:- NestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, d, e, f, ny], build=[right])\n:  :- Calc(select=[a], where=[(a > 10)])\n:  :  +- [#3] BoundedStreamScan(table=[[default_catalog, default_database, chainable]], fields=[a])\n:  +- [#2] Exchange(distribution=[broadcast])\n+- [#1] Exchange(distribution=[broadcast])\n])
+:- Exchange(distribution=[broadcast])
+:  +- Calc(select=[a, b, c], where=[(a > 10)])
+:     +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
+:- Exchange(distribution=[broadcast])
+:  +- Calc(select=[d, e, f, ny], where=[(d > 10)])
 :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-:- Reused(reference_id=[1])
-+- Exchange(distribution=[hash[a]])
-   +- Calc(select=[a])
-      +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
++- BoundedStreamScan(table=[[default_catalog, default_database, chainable]], fields=[a])
 ]]>
     </Resource>
   </TestCase>
@@ -992,20 +962,20 @@ LogicalProject(a=[$0], cnt=[$1], d=[$2], sm=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, cnt, d, sm], build=[right])
-:- Exchange(distribution=[hash[a]])
+HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, cnt, d, sm], build=[left])
+:- Exchange(distribution=[keep_input_as_is[hash[a]]])
 :  +- HashAggregate(isMerge=[false], groupBy=[a], select=[a, COUNT(*) AS cnt])
 :     +- Exchange(distribution=[keep_input_as_is[hash[a]]])
 :        +- Calc(select=[a])
 :           +- Exchange(distribution=[keep_input_as_is[hash[a]]])
-:              +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])(reuse_id=[1])
+:              +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])(reuse_id=[1])
 :                 :- Exchange(distribution=[hash[a]])
 :                 :  +- Calc(select=[a])
 :                 :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
 :                 +- Exchange(distribution=[hash[d]])
 :                    +- Calc(select=[d])
 :                       +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-+- Exchange(distribution=[keep_input_as_is[hash[d]]])
++- Exchange(distribution=[hash[d]])
    +- HashAggregate(isMerge=[false], groupBy=[d], select=[d, SUM(a) AS sm])
       +- Exchange(distribution=[keep_input_as_is[hash[d]]])
          +- Reused(reference_id=[1])
@@ -1043,20 +1013,20 @@ LogicalProject(a=[$0], cnt=[$1], d=[$2], sm=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, cnt, d, sm], build=[right])
-:- Exchange(distribution=[hash[a]])
+HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, cnt, d, sm], build=[left])
+:- Exchange(distribution=[keep_input_as_is[hash[a]]])
 :  +- HashAggregate(isMerge=[false], groupBy=[a], select=[a, COUNT(*) AS cnt])
 :     +- Exchange(distribution=[keep_input_as_is[hash[a]]])
 :        +- Calc(select=[a])
 :           +- Exchange(distribution=[keep_input_as_is[hash[a]]])
-:              +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])(reuse_id=[1])
+:              +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])(reuse_id=[1])
 :                 :- Exchange(distribution=[hash[a]])
 :                 :  +- Calc(select=[a])
 :                 :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
 :                 +- Exchange(distribution=[hash[d]])
 :                    +- Calc(select=[d])
 :                       +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-+- Exchange(distribution=[keep_input_as_is[hash[d]]])
++- Exchange(distribution=[hash[d]])
    +- HashAggregate(isMerge=[false], groupBy=[d], select=[d, SUM(a) AS sm])
       +- Exchange(distribution=[keep_input_as_is[hash[d]]])
          +- Reused(reference_id=[1])
@@ -1094,20 +1064,20 @@ LogicalProject(a=[$0], cnt=[$1], d=[$2], sm=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, cnt, d, sm], build=[right])
-:- Exchange(distribution=[hash[a]])
+HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, cnt, d, sm], build=[left])
+:- Exchange(distribution=[keep_input_as_is[hash[a]]])
 :  +- HashAggregate(isMerge=[false], groupBy=[a], select=[a, COUNT(*) AS cnt])
 :     +- Exchange(distribution=[keep_input_as_is[hash[a]]])
 :        +- Calc(select=[a])
 :           +- Exchange(distribution=[keep_input_as_is[hash[a]]])
-:              +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])(reuse_id=[1])
+:              +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])(reuse_id=[1])
 :                 :- Exchange(distribution=[hash[a]])
 :                 :  +- Calc(select=[a])
 :                 :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
 :                 +- Exchange(distribution=[hash[d]])
 :                    +- Calc(select=[d])
 :                       +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-+- Exchange(distribution=[keep_input_as_is[hash[d]]])
++- Exchange(distribution=[hash[d]])
    +- HashAggregate(isMerge=[false], groupBy=[d], select=[d, SUM(a) AS sm])
       +- Exchange(distribution=[keep_input_as_is[hash[d]]])
          +- Reused(reference_id=[1])
@@ -1174,6 +1144,48 @@ MultipleInput(readOrder=[1,0], members=[\nNestedLoopJoin(joinType=[LeftOuterJoin
 :- BoundedStreamScan(table=[[default_catalog, default_database, chainable]], fields=[a])
 +- Exchange(distribution=[broadcast])
    +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testKeepUsefulUnion[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
+    <Resource name="sql">
+      <![CDATA[
+WITH
+  T1 AS (SELECT chainable.a AS a FROM chainable LEFT JOIN x ON chainable.a = x.a),
+  T2 AS (SELECT chainable.a AS a FROM chainable LEFT JOIN y ON chainable.a = y.d)
+SELECT * FROM
+  (SELECT a FROM T1)
+  UNION ALL
+  (SELECT a FROM T2)
+]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalUnion(all=[true])
+:- LogicalProject(a=[$0])
+:  +- LogicalProject(a=[$0])
+:     +- LogicalProject(a=[$0])
+:        +- LogicalJoin(condition=[=($0, $1)], joinType=[left])
+:           :- LogicalTableScan(table=[[default_catalog, default_database, chainable]])
+:           +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
++- LogicalProject(a=[$0])
+   +- LogicalProject(a=[$0])
+      +- LogicalJoin(condition=[=($0, $1)], joinType=[left])
+         :- LogicalTableScan(table=[[default_catalog, default_database, chainable]])
+         +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
+]]>
+    </Resource>
+    <Resource name="optimized exec plan">
+      <![CDATA[
+MultipleInput(readOrder=[1,0,1,0], members=[\nUnion(all=[true], union=[a])\n:- Calc(select=[a])\n:  +- NestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = a0)], select=[a, a0], build=[right])\n:     :- [#1] BoundedStreamScan(table=[[default_catalog, default_database, chainable]], fields=[a])\n:     +- [#2] Exchange(distribution=[broadcast])\n+- Calc(select=[a])\n   +- NestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, d], build=[right])\n      :- [#1] BoundedStreamScan [...]
+:- BoundedStreamScan(table=[[default_catalog, default_database, chainable]], fields=[a])(reuse_id=[1])
+:- Exchange(distribution=[broadcast])
+:  +- Calc(select=[a])
+:     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
+:- Reused(reference_id=[1])
++- Exchange(distribution=[broadcast])
+   +- Calc(select=[d])
+      +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
 ]]>
     </Resource>
   </TestCase>
@@ -1561,101 +1573,37 @@ MultipleInput(readOrder=[0,0,1,1], members=[\nUnion(all=[true], union=[b, sd, sy
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testRelatedInputsWithAgg[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
+  <TestCase name="testNoPriorityConstraint[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
     <Resource name="sql">
       <![CDATA[
-WITH
-  T1 AS (SELECT x.a AS a, y.d AS b FROM y LEFT JOIN x ON y.d = x.a),
-  T2 AS (
-    SELECT a, b FROM
-      (SELECT a, b FROM T1)
-      UNION ALL
-      (SELECT COUNT(x.a) AS a, x.b AS b FROM x GROUP BY x.b))
-SELECT * FROM T2 LEFT JOIN t ON T2.a = t.a
+SELECT * FROM x
+  INNER JOIN y ON x.a = y.d
+  INNER JOIN t ON x.a = t.a
 ]]>
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(a=[$0], b=[$1], a0=[$2], b0=[$3], c=[$4])
-+- LogicalProject(a=[$0], b=[$1], a0=[$2], b0=[$3], c=[$4])
-   +- LogicalJoin(condition=[=($0, $5)], joinType=[left])
-      :- LogicalUnion(all=[true])
-      :  :- LogicalProject(a=[$0], b=[$1])
-      :  :  +- LogicalProject(a=[$0], b=[$1])
-      :  :     +- LogicalProject(a=[$4], b=[$0])
-      :  :        +- LogicalJoin(condition=[=($0, $4)], joinType=[left])
-      :  :           :- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-      :  :           +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
-      :  +- LogicalProject(a=[$1], b=[$0])
-      :     +- LogicalAggregate(group=[{0}], a=[COUNT($1)])
-      :        +- LogicalProject(b=[$1], a=[$0])
-      :           +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
-      +- LogicalProject(a=[$0], b=[$1], c=[$2], a0=[CAST($0):BIGINT])
-         +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+LogicalProject(a=[$0], b=[$1], c=[$2], nx=[$3], d=[$4], e=[$5], f=[$6], ny=[$7], a0=[$8], b0=[$9], c0=[$10])
++- LogicalJoin(condition=[=($0, $8)], joinType=[inner])
+   :- LogicalJoin(condition=[=($0, $4)], joinType=[inner])
+   :  :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+   :  +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
+   +- LogicalTableScan(table=[[default_catalog, default_database, t]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, b, a0, b0, c])
-+- MultipleInput(readOrder=[0,1,0,1], members=[\nNestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = a00)], select=[a, b, a0, b0, c, a00], build=[right])\n:- Union(all=[true], union=[a, b])\n:  :- Calc(select=[CAST(a AS BIGINT) AS a, CAST(d AS BIGINT) AS b])\n:  :  +- NestedLoopJoin(joinType=[LeftOuterJoin], where=[(d = a)], select=[d, a], build=[right])\n:  :     :- [#2] Calc(select=[d])\n:  :     +- [#3] Exchange(distribution=[broadcast])\n:  +- Calc(select=[CAST(a AS BIGINT) AS a, b] [...]
-   :- Exchange(distribution=[broadcast])
-   :  +- Calc(select=[a, b, c, CAST(a AS BIGINT) AS a0])
-   :     +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
-   :- Calc(select=[d])
-   :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-   :- Exchange(distribution=[broadcast])
-   :  +- Calc(select=[a])
-   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])(reuse_id=[1])
-   +- Exchange(distribution=[hash[b]])
-      +- LocalHashAggregate(groupBy=[b], select=[b, Partial_COUNT(a) AS count$0])
-         +- Calc(select=[b, a])
-            +- Reused(reference_id=[1])
+MultipleInput(members=[\nSortMergeJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, nx, d, e, f, ny, a0, b0, c0])\n:- SortMergeJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, nx, d, e, f, ny])\n:  :- [#2] Exchange(distribution=[hash[a]])\n:  +- [#3] Exchange(distribution=[hash[d]])\n+- [#1] Exchange(distribution=[hash[a]])\n])
+:- Exchange(distribution=[hash[a]])
+:  +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
+:- Exchange(distribution=[hash[a]])
+:  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
++- Exchange(distribution=[hash[d]])
+   +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testKeepUsefulUnion[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
-    <Resource name="sql">
-      <![CDATA[
-WITH
-  T1 AS (SELECT chainable.a AS a FROM chainable LEFT JOIN x ON chainable.a = x.a),
-  T2 AS (SELECT chainable.a AS a FROM chainable LEFT JOIN y ON chainable.a = y.d)
-SELECT * FROM
-  (SELECT a FROM T1)
-  UNION ALL
-  (SELECT a FROM T2)
-]]>
-    </Resource>
-    <Resource name="ast">
-      <![CDATA[
-LogicalUnion(all=[true])
-:- LogicalProject(a=[$0])
-:  +- LogicalProject(a=[$0])
-:     +- LogicalProject(a=[$0])
-:        +- LogicalJoin(condition=[=($0, $1)], joinType=[left])
-:           :- LogicalTableScan(table=[[default_catalog, default_database, chainable]])
-:           +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
-+- LogicalProject(a=[$0])
-   +- LogicalProject(a=[$0])
-      +- LogicalJoin(condition=[=($0, $1)], joinType=[left])
-         :- LogicalTableScan(table=[[default_catalog, default_database, chainable]])
-         +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-]]>
-    </Resource>
-    <Resource name="optimized exec plan">
-      <![CDATA[
-MultipleInput(readOrder=[1,0,1,0], members=[\nUnion(all=[true], union=[a])\n:- Calc(select=[a])\n:  +- NestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = a0)], select=[a, a0], build=[right])\n:     :- [#1] BoundedStreamScan(table=[[default_catalog, default_database, chainable]], fields=[a])\n:     +- [#2] Exchange(distribution=[broadcast])\n+- Calc(select=[a])\n   +- NestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, d], build=[right])\n      :- [#1] BoundedStreamScan [...]
-:- BoundedStreamScan(table=[[default_catalog, default_database, chainable]], fields=[a])(reuse_id=[1])
-:- Exchange(distribution=[broadcast])
-:  +- Calc(select=[a])
-:     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
-:- Reused(reference_id=[1])
-+- Exchange(distribution=[broadcast])
-   +- Calc(select=[d])
-      +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testNoPriorityConstraint[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: Default]">
+  <TestCase name="testNoPriorityConstraint[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: Default]">
     <Resource name="sql">
       <![CDATA[
 SELECT * FROM x
@@ -1715,7 +1663,7 @@ MultipleInput(members=[\nSortMergeJoin(joinType=[InnerJoin], where=[(a = a0)], s
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testRelatedInputs[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: Default]">
+  <TestCase name="testRelatedInputs[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
     <Resource name="sql">
       <![CDATA[
 WITH
@@ -1759,7 +1707,7 @@ MultipleInput(readOrder=[0,1,2,1], members=[\nNestedLoopJoin(joinType=[LeftOuter
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testRelatedInputs[shuffleMode: ALL_EXCHANGES_PIPELINED, schedulerType: Default]">
+  <TestCase name="testRelatedInputs[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: Default]">
     <Resource name="sql">
       <![CDATA[
 WITH
@@ -1803,81 +1751,7 @@ MultipleInput(readOrder=[0,1,2,1], members=[\nNestedLoopJoin(joinType=[LeftOuter
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testRemoveRedundantUnion[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
-    <Resource name="sql">
-      <![CDATA[
-WITH
-  T1 AS (SELECT COUNT(*) AS cnt FROM x GROUP BY a),
-  T2 AS (SELECT COUNT(*) AS cnt FROM y GROUP BY d),
-  T3 AS (SELECT a AS cnt FROM x INNER JOIN y ON x.a = y.d),
-  T4 AS (SELECT b AS cnt FROM x INNER JOIN y ON x.b = y.e)
-SELECT cnt FROM
-  (SELECT cnt FROM (SELECT cnt FROM T1) UNION ALL (SELECT cnt FROM T2))
-  UNION ALL
-  (SELECT cnt FROM (SELECT cnt FROM T3) UNION ALL (SELECT cnt FROM T4))
-]]>
-    </Resource>
-    <Resource name="ast">
-      <![CDATA[
-LogicalUnion(all=[true])
-:- LogicalProject(cnt=[$0])
-:  +- LogicalUnion(all=[true])
-:     :- LogicalProject(cnt=[$0])
-:     :  +- LogicalProject(cnt=[$0])
-:     :     +- LogicalProject(cnt=[$1])
-:     :        +- LogicalAggregate(group=[{0}], cnt=[COUNT()])
-:     :           +- LogicalProject(a=[$0])
-:     :              +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
-:     +- LogicalProject(cnt=[$0])
-:        +- LogicalProject(cnt=[$1])
-:           +- LogicalAggregate(group=[{0}], cnt=[COUNT()])
-:              +- LogicalProject(d=[$0])
-:                 +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-+- LogicalUnion(all=[true])
-   :- LogicalProject(cnt=[$0])
-   :  +- LogicalProject(cnt=[$0])
-   :     +- LogicalProject(cnt=[$0])
-   :        +- LogicalJoin(condition=[=($0, $4)], joinType=[inner])
-   :           :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
-   :           +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-   +- LogicalProject(cnt=[$0])
-      +- LogicalProject(cnt=[$1])
-         +- LogicalJoin(condition=[=($1, $5)], joinType=[inner])
-            :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
-            +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-]]>
-    </Resource>
-    <Resource name="optimized exec plan">
-      <![CDATA[
-Union(all=[true], union=[cnt])
-:- Union(all=[true], union=[cnt])
-:  :- Calc(select=[CAST(cnt AS BIGINT) AS cnt])
-:  :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count1$0) AS cnt])
-:  :     +- Exchange(distribution=[hash[a]])
-:  :        +- LocalHashAggregate(groupBy=[a], select=[a, Partial_COUNT(*) AS count1$0])
-:  :           +- Calc(select=[a])(reuse_id=[1])
-:  :              +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
-:  +- Calc(select=[CAST(cnt AS BIGINT) AS cnt])
-:     +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count1$0) AS cnt])
-:        +- Exchange(distribution=[hash[d]])
-:           +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(*) AS count1$0])
-:              +- Calc(select=[d])(reuse_id=[2])
-:                 +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-+- MultipleInput(readOrder=[1,0,1,0], members=[\nUnion(all=[true], union=[cnt])\n:- Calc(select=[CAST(a AS BIGINT) AS cnt])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[b AS cnt])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[right])\n      :- [#3] Exchange(distribution=[hash[b]])\n      +- [#4] Exchange(di [...]
-   :- Exchange(distribution=[hash[a]])
-   :  +- Reused(reference_id=[1])
-   :- Exchange(distribution=[hash[d]])
-   :  +- Reused(reference_id=[2])
-   :- Exchange(distribution=[hash[b]])
-   :  +- Calc(select=[b])
-   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
-   +- Exchange(distribution=[hash[e]])
-      +- Calc(select=[e])
-         +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testRelatedInputs[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
+  <TestCase name="testRelatedInputs[shuffleMode: ALL_EXCHANGES_PIPELINED, schedulerType: Default]">
     <Resource name="sql">
       <![CDATA[
 WITH
@@ -1918,6 +1792,110 @@ MultipleInput(readOrder=[0,1,2,1], members=[\nNestedLoopJoin(joinType=[LeftOuter
 +- Exchange(distribution=[broadcast])
    +- Calc(select=[a])
       +- Reused(reference_id=[1])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testRelatedInputsWithAgg[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
+    <Resource name="sql">
+      <![CDATA[
+WITH
+  T1 AS (SELECT x.a AS a, y.d AS b FROM y LEFT JOIN x ON y.d = x.a),
+  T2 AS (
+    SELECT a, b FROM
+      (SELECT a, b FROM T1)
+      UNION ALL
+      (SELECT COUNT(x.a) AS a, x.b AS b FROM x GROUP BY x.b))
+SELECT * FROM T2 LEFT JOIN t ON T2.a = t.a
+]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(a=[$0], b=[$1], a0=[$2], b0=[$3], c=[$4])
++- LogicalProject(a=[$0], b=[$1], a0=[$2], b0=[$3], c=[$4])
+   +- LogicalJoin(condition=[=($0, $5)], joinType=[left])
+      :- LogicalUnion(all=[true])
+      :  :- LogicalProject(a=[$0], b=[$1])
+      :  :  +- LogicalProject(a=[$0], b=[$1])
+      :  :     +- LogicalProject(a=[$4], b=[$0])
+      :  :        +- LogicalJoin(condition=[=($0, $4)], joinType=[left])
+      :  :           :- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
+      :  :           +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+      :  +- LogicalProject(a=[$1], b=[$0])
+      :     +- LogicalAggregate(group=[{0}], a=[COUNT($1)])
+      :        +- LogicalProject(b=[$1], a=[$0])
+      :           +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+      +- LogicalProject(a=[$0], b=[$1], c=[$2], a0=[CAST($0):BIGINT])
+         +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+]]>
+    </Resource>
+    <Resource name="optimized exec plan">
+      <![CDATA[
+Calc(select=[a, b, a0, b0, c])
++- MultipleInput(readOrder=[0,1,0,1], members=[\nNestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = a00)], select=[a, b, a0, b0, c, a00], build=[right])\n:- Union(all=[true], union=[a, b])\n:  :- Calc(select=[CAST(a AS BIGINT) AS a, CAST(d AS BIGINT) AS b])\n:  :  +- NestedLoopJoin(joinType=[LeftOuterJoin], where=[(d = a)], select=[d, a], build=[right])\n:  :     :- [#2] Calc(select=[d])\n:  :     +- [#3] Exchange(distribution=[broadcast])\n:  +- Calc(select=[CAST(a AS BIGINT) AS a, b] [...]
+   :- Exchange(distribution=[broadcast])
+   :  +- Calc(select=[a, b, c, CAST(a AS BIGINT) AS a0])
+   :     +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
+   :- Calc(select=[d])
+   :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
+   :- Exchange(distribution=[broadcast])
+   :  +- Calc(select=[a])
+   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])(reuse_id=[1])
+   +- Exchange(distribution=[hash[b]])
+      +- LocalHashAggregate(groupBy=[b], select=[b, Partial_COUNT(a) AS count$0])
+         +- Calc(select=[b, a])
+            +- Reused(reference_id=[1])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testRelatedInputsWithAgg[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: Default]">
+    <Resource name="sql">
+      <![CDATA[
+WITH
+  T1 AS (SELECT x.a AS a, y.d AS b FROM y LEFT JOIN x ON y.d = x.a),
+  T2 AS (
+    SELECT a, b FROM
+      (SELECT a, b FROM T1)
+      UNION ALL
+      (SELECT COUNT(x.a) AS a, x.b AS b FROM x GROUP BY x.b))
+SELECT * FROM T2 LEFT JOIN t ON T2.a = t.a
+]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(a=[$0], b=[$1], a0=[$2], b0=[$3], c=[$4])
++- LogicalProject(a=[$0], b=[$1], a0=[$2], b0=[$3], c=[$4])
+   +- LogicalJoin(condition=[=($0, $5)], joinType=[left])
+      :- LogicalUnion(all=[true])
+      :  :- LogicalProject(a=[$0], b=[$1])
+      :  :  +- LogicalProject(a=[$0], b=[$1])
+      :  :     +- LogicalProject(a=[$4], b=[$0])
+      :  :        +- LogicalJoin(condition=[=($0, $4)], joinType=[left])
+      :  :           :- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
+      :  :           +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+      :  +- LogicalProject(a=[$1], b=[$0])
+      :     +- LogicalAggregate(group=[{0}], a=[COUNT($1)])
+      :        +- LogicalProject(b=[$1], a=[$0])
+      :           +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+      +- LogicalProject(a=[$0], b=[$1], c=[$2], a0=[CAST($0):BIGINT])
+         +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+]]>
+    </Resource>
+    <Resource name="optimized exec plan">
+      <![CDATA[
+Calc(select=[a, b, a0, b0, c])
++- MultipleInput(readOrder=[0,1,0,1], members=[\nNestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = a00)], select=[a, b, a0, b0, c, a00], build=[right])\n:- Union(all=[true], union=[a, b])\n:  :- Calc(select=[CAST(a AS BIGINT) AS a, CAST(d AS BIGINT) AS b])\n:  :  +- NestedLoopJoin(joinType=[LeftOuterJoin], where=[(d = a)], select=[d, a], build=[right])\n:  :     :- [#2] Calc(select=[d])\n:  :     +- [#3] Exchange(distribution=[broadcast])\n:  +- Calc(select=[CAST(a AS BIGINT) AS a, b] [...]
+   :- Exchange(distribution=[broadcast])
+   :  +- Calc(select=[a, b, c, CAST(a AS BIGINT) AS a0])
+   :     +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
+   :- Calc(select=[d])
+   :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
+   :- Exchange(distribution=[broadcast])
+   :  +- Calc(select=[a])
+   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])(reuse_id=[1])
+   +- Exchange(distribution=[hash[b]])
+      +- LocalHashAggregate(groupBy=[b], select=[b, Partial_COUNT(a) AS count$0])
+         +- Calc(select=[b, a])
+            +- Reused(reference_id=[1])
 ]]>
     </Resource>
   </TestCase>
@@ -2009,10 +1987,10 @@ LogicalUnion(all=[true])
       <![CDATA[
 Union(all=[true], union=[a, b])
 :- Calc(select=[a, b])
-:  +- MultipleInput(readOrder=[2,1,0], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a0 = b)], select=[a, a0, b], build=[right])\n:- [#1] Exchange(distribution=[hash[a0]])\n+- Calc(select=[b])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[right])\n      :- [#2] Exchange(distribution=[hash[b]])\n      +- [#3] Exchange(distribution=[hash[e]])\n])
+:  +- MultipleInput(readOrder=[2,0,1], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a0 = b)], select=[a, a0, b], build=[right])\n:- [#1] Exchange(distribution=[hash[a0]])\n+- Calc(select=[b])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])\n      :- [#2] Exchange(distribution=[hash[b]])\n      +- [#3] Exchange(distribution=[hash[e]])\n])
 :     :- Exchange(distribution=[hash[a0]])
 :     :  +- Calc(select=[a, CAST(a AS BIGINT) AS a0])
-:     :     +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])
+:     :     +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])
 :     :        :- Exchange(distribution=[hash[a]])
 :     :        :  +- Calc(select=[a])
 :     :        :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
@@ -2030,55 +2008,60 @@ Union(all=[true], union=[a, b])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testRelatedInputsWithAgg[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: Default]">
+  <TestCase name="testRemoveOneInputOperatorFromRoot[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: Default]">
     <Resource name="sql">
       <![CDATA[
 WITH
-  T1 AS (SELECT x.a AS a, y.d AS b FROM y LEFT JOIN x ON y.d = x.a),
-  T2 AS (
-    SELECT a, b FROM
-      (SELECT a, b FROM T1)
-      UNION ALL
-      (SELECT COUNT(x.a) AS a, x.b AS b FROM x GROUP BY x.b))
-SELECT * FROM T2 LEFT JOIN t ON T2.a = t.a
+  T1 AS (SELECT a FROM x INNER JOIN y ON x.a = y.d),
+  T2 AS (SELECT b FROM x INNER JOIN y ON x.b = y.e)
+SELECT * FROM
+  (SELECT a, b FROM T1 LEFT JOIN T2 ON T1.a = T2.b)
+  UNION ALL
+  (SELECT a, b FROM x)
 ]]>
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(a=[$0], b=[$1], a0=[$2], b0=[$3], c=[$4])
-+- LogicalProject(a=[$0], b=[$1], a0=[$2], b0=[$3], c=[$4])
-   +- LogicalJoin(condition=[=($0, $5)], joinType=[left])
-      :- LogicalUnion(all=[true])
-      :  :- LogicalProject(a=[$0], b=[$1])
-      :  :  +- LogicalProject(a=[$0], b=[$1])
-      :  :     +- LogicalProject(a=[$4], b=[$0])
-      :  :        +- LogicalJoin(condition=[=($0, $4)], joinType=[left])
-      :  :           :- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-      :  :           +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
-      :  +- LogicalProject(a=[$1], b=[$0])
-      :     +- LogicalAggregate(group=[{0}], a=[COUNT($1)])
-      :        +- LogicalProject(b=[$1], a=[$0])
-      :           +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
-      +- LogicalProject(a=[$0], b=[$1], c=[$2], a0=[CAST($0):BIGINT])
-         +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+LogicalUnion(all=[true])
+:- LogicalProject(a=[$0], b=[$1])
+:  +- LogicalProject(a=[$0], b=[$1])
+:     +- LogicalProject(a=[$0], b=[$2])
+:        +- LogicalJoin(condition=[=($1, $2)], joinType=[left])
+:           :- LogicalProject(a=[$0], a0=[CAST($0):BIGINT])
+:           :  +- LogicalProject(a=[$0])
+:           :     +- LogicalJoin(condition=[=($0, $4)], joinType=[inner])
+:           :        :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+:           :        +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
+:           +- LogicalProject(b=[$1])
+:              +- LogicalJoin(condition=[=($1, $5)], joinType=[inner])
+:                 :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+:                 +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
++- LogicalProject(a=[$0], b=[$1])
+   +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, b, a0, b0, c])
-+- MultipleInput(readOrder=[0,1,0,1], members=[\nNestedLoopJoin(joinType=[LeftOuterJoin], where=[(a = a00)], select=[a, b, a0, b0, c, a00], build=[right])\n:- Union(all=[true], union=[a, b])\n:  :- Calc(select=[CAST(a AS BIGINT) AS a, CAST(d AS BIGINT) AS b])\n:  :  +- NestedLoopJoin(joinType=[LeftOuterJoin], where=[(d = a)], select=[d, a], build=[right])\n:  :     :- [#2] Calc(select=[d])\n:  :     +- [#3] Exchange(distribution=[broadcast])\n:  +- Calc(select=[CAST(a AS BIGINT) AS a, b] [...]
-   :- Exchange(distribution=[broadcast])
-   :  +- Calc(select=[a, b, c, CAST(a AS BIGINT) AS a0])
-   :     +- BoundedStreamScan(table=[[default_catalog, default_database, t]], fields=[a, b, c])
-   :- Calc(select=[d])
-   :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-   :- Exchange(distribution=[broadcast])
-   :  +- Calc(select=[a])
-   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])(reuse_id=[1])
-   +- Exchange(distribution=[hash[b]])
-      +- LocalHashAggregate(groupBy=[b], select=[b, Partial_COUNT(a) AS count$0])
-         +- Calc(select=[b, a])
-            +- Reused(reference_id=[1])
+Union(all=[true], union=[a, b])
+:- Calc(select=[a, b])
+:  +- MultipleInput(readOrder=[2,0,1], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a0 = b)], select=[a, a0, b], build=[right])\n:- [#1] Exchange(distribution=[hash[a0]])\n+- Calc(select=[b])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])\n      :- [#2] Exchange(distribution=[hash[b]])\n      +- [#3] Exchange(distribution=[hash[e]])\n])
+:     :- Exchange(distribution=[hash[a0]])
+:     :  +- Calc(select=[a, CAST(a AS BIGINT) AS a0])
+:     :     +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])
+:     :        :- Exchange(distribution=[hash[a]])
+:     :        :  +- Calc(select=[a])
+:     :        :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
+:     :        +- Exchange(distribution=[hash[d]])
+:     :           +- Calc(select=[d])
+:     :              +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
+:     :- Exchange(distribution=[hash[b]])
+:     :  +- Calc(select=[b])
+:     :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
+:     +- Exchange(distribution=[hash[e]])
+:        +- Calc(select=[e])
+:           +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
++- Calc(select=[a, b])
+   +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
 ]]>
     </Resource>
   </TestCase>
@@ -2118,10 +2101,10 @@ LogicalUnion(all=[true])
       <![CDATA[
 Union(all=[true], union=[a, b])
 :- Calc(select=[a, b])
-:  +- MultipleInput(readOrder=[2,1,0], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a0 = b)], select=[a, a0, b], build=[right])\n:- [#1] Exchange(distribution=[hash[a0]])\n+- Calc(select=[b])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[right])\n      :- [#2] Exchange(distribution=[hash[b]])\n      +- [#3] Exchange(distribution=[hash[e]])\n])
+:  +- MultipleInput(readOrder=[2,0,1], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a0 = b)], select=[a, a0, b], build=[right])\n:- [#1] Exchange(distribution=[hash[a0]])\n+- Calc(select=[b])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])\n      :- [#2] Exchange(distribution=[hash[b]])\n      +- [#3] Exchange(distribution=[hash[e]])\n])
 :     :- Exchange(distribution=[hash[a0]])
 :     :  +- Calc(select=[a, CAST(a AS BIGINT) AS a0])
-:     :     +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])
+:     :     +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])
 :     :        :- Exchange(distribution=[hash[a]])
 :     :        :  +- Calc(select=[a])
 :     :        :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
@@ -2139,7 +2122,7 @@ Union(all=[true], union=[a, b])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testRemoveRedundantUnion[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: Default]">
+  <TestCase name="testRemoveRedundantUnion[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: AdaptiveBatch]">
     <Resource name="sql">
       <![CDATA[
 WITH
@@ -2199,7 +2182,7 @@ Union(all=[true], union=[cnt])
 :           +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(*) AS count1$0])
 :              +- Calc(select=[d])(reuse_id=[2])
 :                 +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-+- MultipleInput(readOrder=[1,0,1,0], members=[\nUnion(all=[true], union=[cnt])\n:- Calc(select=[CAST(a AS BIGINT) AS cnt])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[b AS cnt])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[right])\n      :- [#3] Exchange(distribution=[hash[b]])\n      +- [#4] Exchange(di [...]
++- MultipleInput(readOrder=[0,1,0,1], members=[\nUnion(all=[true], union=[cnt])\n:- Calc(select=[CAST(a AS BIGINT) AS cnt])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[b AS cnt])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])\n      :- [#3] Exchange(distribution=[hash[b]])\n      +- [#4] Exchange(dist [...]
    :- Exchange(distribution=[hash[a]])
    :  +- Reused(reference_id=[1])
    :- Exchange(distribution=[hash[d]])
@@ -2213,60 +2196,77 @@ Union(all=[true], union=[cnt])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testRemoveOneInputOperatorFromRoot[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: Default]">
+  <TestCase name="testRemoveRedundantUnion[shuffleMode: ALL_EXCHANGES_BLOCKING, schedulerType: Default]">
     <Resource name="sql">
       <![CDATA[
 WITH
-  T1 AS (SELECT a FROM x INNER JOIN y ON x.a = y.d),
-  T2 AS (SELECT b FROM x INNER JOIN y ON x.b = y.e)
-SELECT * FROM
-  (SELECT a, b FROM T1 LEFT JOIN T2 ON T1.a = T2.b)
+  T1 AS (SELECT COUNT(*) AS cnt FROM x GROUP BY a),
+  T2 AS (SELECT COUNT(*) AS cnt FROM y GROUP BY d),
+  T3 AS (SELECT a AS cnt FROM x INNER JOIN y ON x.a = y.d),
+  T4 AS (SELECT b AS cnt FROM x INNER JOIN y ON x.b = y.e)
+SELECT cnt FROM
+  (SELECT cnt FROM (SELECT cnt FROM T1) UNION ALL (SELECT cnt FROM T2))
   UNION ALL
-  (SELECT a, b FROM x)
+  (SELECT cnt FROM (SELECT cnt FROM T3) UNION ALL (SELECT cnt FROM T4))
 ]]>
     </Resource>
     <Resource name="ast">
       <![CDATA[
 LogicalUnion(all=[true])
-:- LogicalProject(a=[$0], b=[$1])
-:  +- LogicalProject(a=[$0], b=[$1])
-:     +- LogicalProject(a=[$0], b=[$2])
-:        +- LogicalJoin(condition=[=($1, $2)], joinType=[left])
-:           :- LogicalProject(a=[$0], a0=[CAST($0):BIGINT])
-:           :  +- LogicalProject(a=[$0])
-:           :     +- LogicalJoin(condition=[=($0, $4)], joinType=[inner])
-:           :        :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
-:           :        +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-:           +- LogicalProject(b=[$1])
-:              +- LogicalJoin(condition=[=($1, $5)], joinType=[inner])
-:                 :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+:- LogicalProject(cnt=[$0])
+:  +- LogicalUnion(all=[true])
+:     :- LogicalProject(cnt=[$0])
+:     :  +- LogicalProject(cnt=[$0])
+:     :     +- LogicalProject(cnt=[$1])
+:     :        +- LogicalAggregate(group=[{0}], cnt=[COUNT()])
+:     :           +- LogicalProject(a=[$0])
+:     :              +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+:     +- LogicalProject(cnt=[$0])
+:        +- LogicalProject(cnt=[$1])
+:           +- LogicalAggregate(group=[{0}], cnt=[COUNT()])
+:              +- LogicalProject(d=[$0])
 :                 +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
-+- LogicalProject(a=[$0], b=[$1])
-   +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
++- LogicalUnion(all=[true])
+   :- LogicalProject(cnt=[$0])
+   :  +- LogicalProject(cnt=[$0])
+   :     +- LogicalProject(cnt=[$0])
+   :        +- LogicalJoin(condition=[=($0, $4)], joinType=[inner])
+   :           :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+   :           +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
+   +- LogicalProject(cnt=[$0])
+      +- LogicalProject(cnt=[$1])
+         +- LogicalJoin(condition=[=($1, $5)], joinType=[inner])
+            :- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]])
+            +- LogicalTableScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Union(all=[true], union=[a, b])
-:- Calc(select=[a, b])
-:  +- MultipleInput(readOrder=[2,1,0], members=[\nHashJoin(joinType=[LeftOuterJoin], where=[(a0 = b)], select=[a, a0, b], build=[right])\n:- [#1] Exchange(distribution=[hash[a0]])\n+- Calc(select=[b])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[right])\n      :- [#2] Exchange(distribution=[hash[b]])\n      +- [#3] Exchange(distribution=[hash[e]])\n])
-:     :- Exchange(distribution=[hash[a0]])
-:     :  +- Calc(select=[a, CAST(a AS BIGINT) AS a0])
-:     :     +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])
-:     :        :- Exchange(distribution=[hash[a]])
-:     :        :  +- Calc(select=[a])
-:     :        :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
-:     :        +- Exchange(distribution=[hash[d]])
-:     :           +- Calc(select=[d])
-:     :              +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-:     :- Exchange(distribution=[hash[b]])
-:     :  +- Calc(select=[b])
-:     :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
-:     +- Exchange(distribution=[hash[e]])
-:        +- Calc(select=[e])
-:           +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-+- Calc(select=[a, b])
-   +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
+Union(all=[true], union=[cnt])
+:- Union(all=[true], union=[cnt])
+:  :- Calc(select=[CAST(cnt AS BIGINT) AS cnt])
+:  :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count1$0) AS cnt])
+:  :     +- Exchange(distribution=[hash[a]])
+:  :        +- LocalHashAggregate(groupBy=[a], select=[a, Partial_COUNT(*) AS count1$0])
+:  :           +- Calc(select=[a])(reuse_id=[1])
+:  :              +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
+:  +- Calc(select=[CAST(cnt AS BIGINT) AS cnt])
+:     +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count1$0) AS cnt])
+:        +- Exchange(distribution=[hash[d]])
+:           +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(*) AS count1$0])
+:              +- Calc(select=[d])(reuse_id=[2])
+:                 +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
++- MultipleInput(readOrder=[0,1,0,1], members=[\nUnion(all=[true], union=[cnt])\n:- Calc(select=[CAST(a AS BIGINT) AS cnt])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[b AS cnt])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])\n      :- [#3] Exchange(distribution=[hash[b]])\n      +- [#4] Exchange(dist [...]
+   :- Exchange(distribution=[hash[a]])
+   :  +- Reused(reference_id=[1])
+   :- Exchange(distribution=[hash[d]])
+   :  +- Reused(reference_id=[2])
+   :- Exchange(distribution=[hash[b]])
+   :  +- Calc(select=[b])
+   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c, nx)]]], fields=[a, b, c, nx])
+   +- Exchange(distribution=[hash[e]])
+      +- Calc(select=[e])
+         +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
 ]]>
     </Resource>
   </TestCase>
@@ -2330,7 +2330,7 @@ Union(all=[true], union=[cnt])
 :           +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(*) AS count1$0])
 :              +- Calc(select=[d])(reuse_id=[2])
 :                 +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f, ny)]]], fields=[d, e, f, ny])
-+- MultipleInput(readOrder=[1,0,1,0], members=[\nUnion(all=[true], union=[cnt])\n:- Calc(select=[CAST(a AS BIGINT) AS cnt])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[b AS cnt])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[right])\n      :- [#3] Exchange(distribution=[hash[b]])\n      +- [#4] Exchange(di [...]
++- MultipleInput(readOrder=[0,1,0,1], members=[\nUnion(all=[true], union=[cnt])\n:- Calc(select=[CAST(a AS BIGINT) AS cnt])\n:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])\n:     :- [#1] Exchange(distribution=[hash[a]])\n:     +- [#2] Exchange(distribution=[hash[d]])\n+- Calc(select=[b AS cnt])\n   +- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])\n      :- [#3] Exchange(distribution=[hash[b]])\n      +- [#4] Exchange(dist [...]
    :- Exchange(distribution=[hash[a]])
    :  +- Reused(reference_id=[1])
    :- Exchange(distribution=[hash[d]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/RemoveShuffleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/RemoveShuffleTest.xml
index 975a8a430ad..fba75b39f7f 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/RemoveShuffleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/RemoveShuffleTest.xml
@@ -325,7 +325,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4], f=[$5], a0=[$6], b0=[$7],
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[0,2,0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[right])\n:- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[left])\n:  :- [#1] Exchange(distribution=[hash[a]])\n:  +- [#2] Exchange(distribution=[hash[d]])\n+- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[left])\n   :- [#3] Exchange(distribution=[hash[a]])\n   +- [#4 [...]
+MultipleInput(readOrder=[0,1,0,2], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[left])\n:- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[left])\n:  :- [#1] Exchange(distribution=[hash[a]])\n:  +- [#2] Exchange(distribution=[hash[d]])\n+- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[left])\n   :- [#3] Exchange(distribution=[hash[a]])\n   +- [#4] [...]
 :- Exchange(distribution=[hash[a]])
 :  +- Calc(select=[a, b, c], where=[LIKE(c, 'He%')])
 :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -362,7 +362,7 @@ LogicalProject(a=[$0], c=[$1], EXPR$2=[$2], a0=[$3], c0=[$4], EXPR$20=[$5])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[((a = a0) AND (c = c0))], select=[a, c, EXPR$2, a0, c0, EXPR$20], build=[right])\n:- HashAggregate(isMerge=[true], groupBy=[a, c], select=[a, c, Final_SUM(sum$0) AS EXPR$2])\n:  +- [#1] Exchange(distribution=[hash[a, c]])\n+- HashAggregate(isMerge=[true], groupBy=[a, c], select=[a, c, Final_SUM(sum$0) AS EXPR$2])\n   +- [#2] Exchange(distribution=[hash[a, c]])\n])
+MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[((a = a0) AND (c = c0))], select=[a, c, EXPR$2, a0, c0, EXPR$20], build=[left])\n:- HashAggregate(isMerge=[true], groupBy=[a, c], select=[a, c, Final_SUM(sum$0) AS EXPR$2])\n:  +- [#1] Exchange(distribution=[hash[a, c]])\n+- HashAggregate(isMerge=[true], groupBy=[a, c], select=[a, c, Final_SUM(sum$0) AS EXPR$2])\n   +- [#2] Exchange(distribution=[hash[a, c]])\n])
 :- Exchange(distribution=[hash[a, c]])
 :  +- LocalHashAggregate(groupBy=[a, c], select=[a, c, Partial_SUM(b) AS sum$0])
 :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -400,7 +400,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4], f=[$5], a0=[$6], b0=[$7],
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[left])
 :- Exchange(distribution=[hash[a]])
 :  +- HashJoin(joinType=[FullOuterJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[right])
 :     :- Exchange(distribution=[hash[a]])
@@ -446,7 +446,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4], f=[$5], a0=[$6], b0=[$7],
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[0,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[right])\n:- HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[right])\n:  :- [#2] Exchange(distribution=[hash[a]])\n:  +- [#3] Exchange(distribution=[hash[d]])\n+- [#1] Exchange(distribution=[hash[d]])\n])
+MultipleInput(readOrder=[2,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[left])\n:- HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[right])\n:  :- [#2] Exchange(distribution=[hash[a]])\n:  +- [#3] Exchange(distribution=[hash[d]])\n+- [#1] Exchange(distribution=[hash[d]])\n])
 :- Exchange(distribution=[hash[d]])
 :  +- HashJoin(joinType=[LeftOuterJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[right])
 :     :- Exchange(distribution=[hash[a]])
@@ -490,7 +490,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4], f=[$5], a0=[$6], b0=[$7],
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[2,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[right])\n:- [#1] Exchange(distribution=[hash[a]])\n+- HashJoin(joinType=[RightOuterJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[right])\n   :- [#2] Exchange(distribution=[hash[a]])\n   +- [#3] Exchange(distribution=[hash[d]])\n])
+MultipleInput(readOrder=[0,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[left])\n:- [#1] Exchange(distribution=[hash[a]])\n+- HashJoin(joinType=[RightOuterJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[right])\n   :- [#2] Exchange(distribution=[hash[a]])\n   +- [#3] Exchange(distribution=[hash[d]])\n])
 :- Exchange(distribution=[hash[a]])
 :  +- HashJoin(joinType=[RightOuterJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[right])
 :     :- Exchange(distribution=[hash[a]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/SetOperatorsTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/SetOperatorsTest.xml
index 717adb1ad89..7c13155b767 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/SetOperatorsTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/SetOperatorsTest.xml
@@ -33,7 +33,7 @@ LogicalIntersect(all=[false])
       <![CDATA[
 HashAggregate(isMerge=[false], groupBy=[c], select=[c])
 +- Exchange(distribution=[keep_input_as_is[hash[c]]])
-   +- HashJoin(joinType=[LeftSemiJoin], where=[IS NOT DISTINCT FROM(c, f)], select=[c], build=[left])
+   +- HashJoin(joinType=[LeftSemiJoin], where=[IS NOT DISTINCT FROM(c, f)], select=[c], build=[right])
       :- Exchange(distribution=[hash[c]])
       :  +- Calc(select=[c])
       :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -131,7 +131,7 @@ LogicalProject(a=[$0])
 Calc(select=[a])
 +- HashAggregate(isMerge=[false], groupBy=[a, b], select=[a, b])
    +- Exchange(distribution=[keep_input_as_is[hash[a, b]]])
-      +- HashJoin(joinType=[LeftSemiJoin], where=[(((a = d) OR (a IS NULL AND d IS NULL)) AND ((b = e) OR (b IS NULL AND e IS NULL)))], select=[a, b], build=[left])
+      +- HashJoin(joinType=[LeftSemiJoin], where=[(((a = d) OR (a IS NULL AND d IS NULL)) AND ((b = e) OR (b IS NULL AND e IS NULL)))], select=[a, b], build=[right])
          :- Exchange(distribution=[hash[a, b]])
          :  +- Calc(select=[a, b])
          :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -158,7 +158,7 @@ LogicalMinus(all=[false])
       <![CDATA[
 HashAggregate(isMerge=[false], groupBy=[c], select=[c])
 +- Exchange(distribution=[keep_input_as_is[hash[c]]])
-   +- HashJoin(joinType=[LeftAntiJoin], where=[IS NOT DISTINCT FROM(c, f)], select=[c], build=[left])
+   +- HashJoin(joinType=[LeftAntiJoin], where=[IS NOT DISTINCT FROM(c, f)], select=[c], build=[right])
       :- Exchange(distribution=[hash[c]])
       :  +- Calc(select=[c])
       :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -258,10 +258,10 @@ LogicalMinus(all=[false])
       <![CDATA[
 HashAggregate(isMerge=[false], groupBy=[a, b, c], select=[a, b, c])
 +- Exchange(distribution=[keep_input_as_is[hash[a, b, c]]])
-   +- HashJoin(joinType=[LeftAntiJoin], where=[(((a = a0) OR (a IS NULL AND a0 IS NULL)) AND ((b = b0) OR (b IS NULL AND b0 IS NULL)) AND ((c = c0) OR (c IS NULL AND c0 IS NULL)))], select=[a, b, c], build=[left])
-      :- Exchange(distribution=[hash[a, b, c]])
+   +- HashJoin(joinType=[LeftAntiJoin], where=[(((a = a0) OR (a IS NULL AND a0 IS NULL)) AND ((b = b0) OR (b IS NULL AND b0 IS NULL)) AND ((c = c0) OR (c IS NULL AND c0 IS NULL)))], select=[a, b, c], build=[right])
+      :- Exchange(distribution=[hash[a, b, c]], shuffle_mode=[BATCH])
       :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])(reuse_id=[1])
-      +- Exchange(distribution=[hash[a, b, c]], shuffle_mode=[BATCH])
+      +- Exchange(distribution=[hash[a, b, c]])
          +- Reused(reference_id=[1])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/SubplanReuseTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/SubplanReuseTest.xml
index bbc137a2477..e0fbe17efbd 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/SubplanReuseTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/SubplanReuseTest.xml
@@ -112,9 +112,9 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4], f=[$5], a0=[$6], b0=[$7],
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[left])
 :- Exchange(distribution=[hash[b]])
-:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[right])
+:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[left])
 :     :- Exchange(distribution=[hash[a]])
 :     :  +- Calc(select=[a, b, c], where=[(a < 10)])
 :     :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -122,7 +122,7 @@ HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, c, d, e, f, a0, b
 :        +- Calc(select=[d, e, f], where=[(d < 10)])
 :           +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
 +- Exchange(distribution=[hash[e]])
-   +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[right])
+   +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[left])
       :- Exchange(distribution=[hash[a]])
       :  +- Calc(select=[a, b, c], where=[(a > 5)])
       :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -161,9 +161,9 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3], a0=[$4], b0=[$5], d0=[$6], e0=[$7
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, d, e, a0, b0, d0, e0], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, d, e, a0, b0, d0, e0], build=[left])
 :- Exchange(distribution=[hash[b]])
-:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[right])
+:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[left])
 :     :- Exchange(distribution=[hash[a]])
 :     :  +- Calc(select=[a, b], where=[(a < 10)])
 :     :     +- TableSourceScan(table=[[default_catalog, default_database, newX, filter=[], project=[a, b], metadata=[]]], fields=[a, b])
@@ -171,7 +171,7 @@ HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, d, e, a0, b0, d0,
 :        +- Calc(select=[d, e], where=[(d < 10)])
 :           +- TableSourceScan(table=[[default_catalog, default_database, newY, filter=[], project=[d, e], metadata=[]]], fields=[d, e])
 +- Exchange(distribution=[hash[e]])
-   +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[right])
+   +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[left])
       :- Exchange(distribution=[hash[a]])
       :  +- Calc(select=[a, b], where=[(a > 5)])
       :     +- TableSourceScan(table=[[default_catalog, default_database, newX, filter=[], project=[a, b], metadata=[]]], fields=[a, b])
@@ -207,9 +207,9 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3], a0=[$4], b0=[$5], d0=[$6], e0=[$7
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, d, e, a0, b0, d0, e0], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, d, e, a0, b0, d0, e0], build=[left])
 :- Exchange(distribution=[hash[b]])
-:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[right])
+:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[left])
 :     :- Exchange(distribution=[hash[a]])
 :     :  +- Calc(select=[a, b], where=[(a < 10)])
 :     :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])(reuse_id=[1])
@@ -217,7 +217,7 @@ HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, d, e, a0, b0, d0,
 :        +- Calc(select=[d, e], where=[(d < 10)])
 :           +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])(reuse_id=[2])
 +- Exchange(distribution=[hash[e]])
-   +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[right])
+   +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[left])
       :- Exchange(distribution=[hash[a]])
       :  +- Calc(select=[a, b], where=[(a > 5)])
       :     +- Reused(reference_id=[1])
@@ -256,9 +256,9 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3], a0=[$4], b0=[$5], d0=[$6], e0=[$7
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, d, e, a0, b0, d0, e0], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, d, e, a0, b0, d0, e0], build=[left])
 :- Exchange(distribution=[hash[b]])
-:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[right])
+:  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[left])
 :     :- Exchange(distribution=[hash[a]])
 :     :  +- Calc(select=[a, b], where=[(a < 10)])
 :     :     +- TableSourceScan(table=[[default_catalog, default_database, newX, filter=[], project=[a, b], metadata=[]]], fields=[a, b])(reuse_id=[1])
@@ -266,7 +266,7 @@ HashJoin(joinType=[InnerJoin], where=[(b = e0)], select=[a, b, d, e, a0, b0, d0,
 :        +- Calc(select=[d, e], where=[(d < 10)])
 :           +- TableSourceScan(table=[[default_catalog, default_database, newY, filter=[], project=[d, e], metadata=[]]], fields=[d, e])(reuse_id=[2])
 +- Exchange(distribution=[hash[e]])
-   +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[right])
+   +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, d, e], build=[left])
       :- Exchange(distribution=[hash[a]])
       :  +- Calc(select=[a, b], where=[(a > 5)])
       :     +- Reused(reference_id=[1])
@@ -441,11 +441,11 @@ LogicalProject(a=[$0], b=[$1], c=[$2], a0=[$3], b0=[$4], c0=[$5])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, a0, b0, c0], build=[right])
-:- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
+HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, a0, b0, c0], build=[left])
+:- Exchange(distribution=[hash[a]])
 :  +- Calc(select=[a, b, c], where=[(a > 5)])(reuse_id=[1])
 :     +- TableSourceScan(table=[[default_catalog, default_database, MyTable, filter=[]]], fields=[a, b, c])
-+- Exchange(distribution=[hash[a]])
++- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
    +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -467,11 +467,11 @@ LogicalProject(a=[$0], b=[$1], c=[$2], a0=[$3], b0=[$4], c0=[$5])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, a0, b0, c0], build=[right])
-:- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
+HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, a0, b0, c0], build=[left])
+:- Exchange(distribution=[hash[a]])
 :  +- Calc(select=[a, b, c], where=[(a > 5)])(reuse_id=[1])
 :     +- TableSourceScan(table=[[default_catalog, default_database, MyTable, filter=[]]], fields=[a, b, c])
-+- Exchange(distribution=[hash[a]])
++- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
    +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -493,11 +493,11 @@ LogicalProject(a=[$0], b=[$1], c=[$2], a0=[$3], b0=[$4], c0=[$5])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, a0, b0, c0], build=[right])
-:- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
+HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, a0, b0, c0], build=[left])
+:- Exchange(distribution=[hash[a]])
 :  +- Calc(select=[a, b, c], where=[(a < 10)])(reuse_id=[1])
 :     +- TableSourceScan(table=[[default_catalog, default_database, MyTable, filter=[]]], fields=[a, b, c])
-+- Exchange(distribution=[hash[a]])
++- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
    +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -659,7 +659,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], v=[$3], a0=[$4], b0=[$5], c0=[$6], v0=[$7
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(EXPR$0 = EXPR$00)], select=[a, b, c, EXPR$0, a0, b0, c0, EXPR$00], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(EXPR$0 = EXPR$00)], select=[a, b, c, EXPR$0, a0, b0, c0, EXPR$00], build=[left])
 :- Exchange(distribution=[hash[EXPR$0]])
 :  +- Correlate(invocation=[str_split($cor0.c, _UTF-16LE'-')], correlate=[table(str_split($cor0.c,'-'))], select=[a,b,c,EXPR$0], rowType=[RecordType(INTEGER a, BIGINT b, VARCHAR(2147483647) c, VARCHAR(2147483647) EXPR$0)], joinType=[INNER])
 :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -693,7 +693,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], s=[$3], a0=[$4], b0=[$5], c0=[$6], s0=[$7
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(c = EXPR$00)], select=[a, b, c, EXPR$0, a0, b0, c0, EXPR$00], build=[right])\n:- Correlate(invocation=[TableFun($cor0.c)], correlate=[table(TableFun($cor0.c))], select=[a,b,c,EXPR$0], rowType=[RecordType(INTEGER a, BIGINT b, VARCHAR(2147483647) c, VARCHAR(2147483647) EXPR$0)], joinType=[INNER])\n:  +- [#2] Exchange(distribution=[hash[c]])\n+- [#1] Exchange(distribution=[hash[EXPR$0]])\n])
+MultipleInput(readOrder=[1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(c = EXPR$00)], select=[a, b, c, EXPR$0, a0, b0, c0, EXPR$00], build=[left])\n:- Correlate(invocation=[TableFun($cor0.c)], correlate=[table(TableFun($cor0.c))], select=[a,b,c,EXPR$0], rowType=[RecordType(INTEGER a, BIGINT b, VARCHAR(2147483647) c, VARCHAR(2147483647) EXPR$0)], joinType=[INNER])\n:  +- [#2] Exchange(distribution=[hash[c]])\n+- [#1] Exchange(distribution=[hash[EXPR$0]])\n])
 :- Exchange(distribution=[hash[EXPR$0]])
 :  +- Correlate(invocation=[TableFun($cor1.c)], correlate=[table(TableFun($cor1.c))], select=[a,b,c,EXPR$0], rowType=[RecordType(INTEGER a, BIGINT b, VARCHAR(2147483647) c, VARCHAR(2147483647) EXPR$0)], joinType=[INNER])
 :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -873,15 +873,15 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4], f=[$5], a0=[$6], b0=[$7],
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[right])
-:- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
+HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0], build=[left])
+:- Exchange(distribution=[keep_input_as_is[hash[a]]])
 :  +- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[left])(reuse_id=[1])
 :     :- Exchange(distribution=[hash[a]])
 :     :  +- Calc(select=[a, b, c], where=[LIKE(c, 'He%')])
 :     :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
 :     +- Exchange(distribution=[hash[d]])
 :        +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
-+- Exchange(distribution=[keep_input_as_is[hash[d]]])
++- Exchange(distribution=[hash[d]], shuffle_mode=[BATCH])
    +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -1064,7 +1064,7 @@ LogicalProject(a=[$0], b=[$1], EXPR$2=[$2], a0=[$3], b0=[$4], EXPR$20=[$5])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, w0$o0, a0, b0, w0$o00], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, w0$o0, a0, b0, w0$o00], build=[left])
 :- Exchange(distribution=[hash[a]])
 :  +- Calc(select=[a, b, w0$o0], where=[(b < 100)])
 :     +- OverAggregate(partitionBy=[c], orderBy=[c DESC], window#0=[MyFirst(c) AS w0$o0 RANG BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0])(reuse_id=[1])
@@ -1173,7 +1173,7 @@ LogicalProject(a=[$0], b=[$1], EXPR$2=[$2], a0=[$3], b0=[$4], EXPR$20=[$5])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, w0$o0, a0, b0, w0$o00], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, w0$o0, a0, b0, w0$o00], build=[left])
 :- Exchange(distribution=[hash[a]])
 :  +- Calc(select=[a, b, w0$o0], where=[(b < 100)])
 :     +- OverAggregate(orderBy=[c DESC], window#0=[RANK(*) AS w0$o0 RANG BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0])(reuse_id=[1])
@@ -1294,14 +1294,14 @@ LogicalProject(a=[$0], c=[$1], c0=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, c, c0])
-+- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[right])
-   :- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[left])
+   :- Exchange(distribution=[hash[a]])
    :  +- Union(all=[true], union=[a, c])(reuse_id=[1])
    :     :- Calc(select=[a, c], where=[(b > 10)])
    :     :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
    :     +- Calc(select=[d, f], where=[(e < 100)])
    :        +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
-   +- Exchange(distribution=[hash[a]])
+   +- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
       +- Reused(reference_id=[1])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/JoinReorderTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/JoinReorderTest.xml
index c9ad057a825..889fffa4591 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/JoinReorderTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/JoinReorderTest.xml
@@ -383,47 +383,6 @@ Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
                            :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
                            +- Exchange(distribution=[hash[a1]])
                               +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testBushyJoinCondition1[isBushyJoinReorder=false]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT * FROM T1, T2, T3, T4, T5
-WHERE a1 = a2 AND a2 = a3 AND a1 = a4 AND a3 = a5
-         ]]>
-    </Resource>
-    <Resource name="ast">
-      <![CDATA[
-LogicalProject(a1=[$0], b1=[$1], c1=[$2], a2=[$3], b2=[$4], c2=[$5], a3=[$6], b3=[$7], c3=[$8], a4=[$9], b4=[$10], c4=[$11], a5=[$12], b5=[$13], c5=[$14])
-+- LogicalFilter(condition=[AND(=($0, $3), =($3, $6), =($0, $9), =($6, $12))])
-   +- LogicalJoin(condition=[true], joinType=[inner])
-      :- LogicalJoin(condition=[true], joinType=[inner])
-      :  :- LogicalJoin(condition=[true], joinType=[inner])
-      :  :  :- LogicalJoin(condition=[true], joinType=[inner])
-      :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]])
-      :  :  :  +- LogicalTableScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]])
-      :  :  +- LogicalTableScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]])
-      :  +- LogicalTableScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]])
-      +- LogicalTableScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]])
-]]>
-    </Resource>
-    <Resource name="optimized rel plan">
-      <![CDATA[
-Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
-+- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
-   :- HashJoin(joinType=[InnerJoin], where=[=(a2, a4)], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
-   :  :- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
-   :  +- Exchange(distribution=[broadcast])
-   :     +- HashJoin(joinType=[InnerJoin], where=[=(a1, a4)], select=[a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
-   :        :- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
-   :        +- Exchange(distribution=[broadcast])
-   :           +- HashJoin(joinType=[InnerJoin], where=[=(a5, a4)], select=[a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
-   :              :- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
-   :              +- Exchange(distribution=[broadcast])
-   :                 +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
-   +- Exchange(distribution=[broadcast])
-      +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
 ]]>
     </Resource>
   </TestCase>
@@ -468,17 +427,17 @@ Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testBushyJoinCondition2[isBushyJoinReorder=false]">
+  <TestCase name="testBushyJoinCondition1[isBushyJoinReorder=false]">
     <Resource name="sql">
       <![CDATA[
 SELECT * FROM T1, T2, T3, T4, T5
-WHERE b1 = b2 AND b2 = b3 AND b1 = b4 AND b3 = b5
+WHERE a1 = a2 AND a2 = a3 AND a1 = a4 AND a3 = a5
          ]]>
     </Resource>
     <Resource name="ast">
       <![CDATA[
 LogicalProject(a1=[$0], b1=[$1], c1=[$2], a2=[$3], b2=[$4], c2=[$5], a3=[$6], b3=[$7], c3=[$8], a4=[$9], b4=[$10], c4=[$11], a5=[$12], b5=[$13], c5=[$14])
-+- LogicalFilter(condition=[AND(=($1, $4), =($4, $7), =($1, $10), =($7, $13))])
++- LogicalFilter(condition=[AND(=($0, $3), =($3, $6), =($0, $9), =($6, $12))])
    +- LogicalJoin(condition=[true], joinType=[inner])
       :- LogicalJoin(condition=[true], joinType=[inner])
       :  :- LogicalJoin(condition=[true], joinType=[inner])
@@ -493,18 +452,17 @@ LogicalProject(a1=[$0], b1=[$1], c1=[$2], a2=[$3], b2=[$4], c2=[$5], a3=[$6], b3
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
-+- HashJoin(joinType=[InnerJoin], where=[=(b1, b3)], select=[a1, b1, c1, a5, b5, c5, a2, b2, c2, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
-   :- HashJoin(joinType=[InnerJoin], where=[=(b1, b4)], select=[a1, b1, c1, a5, b5, c5, a2, b2, c2, a4, b4, c4], build=[left])
-   :  :- Exchange(distribution=[hash[b1]])
-   :  :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
-   :  +- Exchange(distribution=[hash[b4]])
-   :     +- HashJoin(joinType=[InnerJoin], where=[=(b5, b4)], select=[a5, b5, c5, a2, b2, c2, a4, b4, c4], isBroadcast=[true], build=[right])
-   :        :- HashJoin(joinType=[InnerJoin], where=[=(b5, b2)], select=[a5, b5, c5, a2, b2, c2], isBroadcast=[true], build=[right])
-   :        :  :- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
-   :        :  +- Exchange(distribution=[broadcast])
-   :        :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
++- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
+   :- HashJoin(joinType=[InnerJoin], where=[=(a2, a4)], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
+   :  :- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
+   :  +- Exchange(distribution=[broadcast])
+   :     +- HashJoin(joinType=[InnerJoin], where=[=(a1, a4)], select=[a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
+   :        :- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
    :        +- Exchange(distribution=[broadcast])
-   :           +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
+   :           +- HashJoin(joinType=[InnerJoin], where=[=(a5, a4)], select=[a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
+   :              :- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
+   :              +- Exchange(distribution=[broadcast])
+   :                 +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
    +- Exchange(distribution=[broadcast])
       +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
 ]]>
@@ -549,6 +507,48 @@ Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
       :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
       +- Exchange(distribution=[hash[b5]])
          +- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testBushyJoinCondition2[isBushyJoinReorder=false]">
+    <Resource name="sql">
+      <![CDATA[
+SELECT * FROM T1, T2, T3, T4, T5
+WHERE b1 = b2 AND b2 = b3 AND b1 = b4 AND b3 = b5
+         ]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(a1=[$0], b1=[$1], c1=[$2], a2=[$3], b2=[$4], c2=[$5], a3=[$6], b3=[$7], c3=[$8], a4=[$9], b4=[$10], c4=[$11], a5=[$12], b5=[$13], c5=[$14])
++- LogicalFilter(condition=[AND(=($1, $4), =($4, $7), =($1, $10), =($7, $13))])
+   +- LogicalJoin(condition=[true], joinType=[inner])
+      :- LogicalJoin(condition=[true], joinType=[inner])
+      :  :- LogicalJoin(condition=[true], joinType=[inner])
+      :  :  :- LogicalJoin(condition=[true], joinType=[inner])
+      :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]])
+      :  :  :  +- LogicalTableScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]])
+      :  :  +- LogicalTableScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]])
+      :  +- LogicalTableScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]])
+      +- LogicalTableScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
++- HashJoin(joinType=[InnerJoin], where=[=(b1, b3)], select=[a1, b1, c1, a5, b5, c5, a2, b2, c2, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
+   :- HashJoin(joinType=[InnerJoin], where=[=(b1, b4)], select=[a1, b1, c1, a5, b5, c5, a2, b2, c2, a4, b4, c4], build=[left])
+   :  :- Exchange(distribution=[hash[b1]])
+   :  :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
+   :  +- Exchange(distribution=[hash[b4]])
+   :     +- HashJoin(joinType=[InnerJoin], where=[=(b5, b4)], select=[a5, b5, c5, a2, b2, c2, a4, b4, c4], isBroadcast=[true], build=[right])
+   :        :- HashJoin(joinType=[InnerJoin], where=[=(b5, b2)], select=[a5, b5, c5, a2, b2, c2], isBroadcast=[true], build=[right])
+   :        :  :- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
+   :        :  +- Exchange(distribution=[broadcast])
+   :        :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
+   :        +- Exchange(distribution=[broadcast])
+   :           +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
+   +- Exchange(distribution=[broadcast])
+      +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
 ]]>
     </Resource>
   </TestCase>
@@ -649,7 +649,7 @@ LogicalProject(a6=[$0], b6=[$1], a7=[$2], b7=[$3], a8=[$4], b8=[$5])
 Calc(select=[a6, b6, a7, b7, a8, b8])
 +- HashJoin(joinType=[InnerJoin], where=[=(b6, b7)], select=[a6, b6, a8, b8, a7, b7], build=[right])
    :- Exchange(distribution=[hash[b6]])
-   :  +- HashJoin(joinType=[InnerJoin], where=[=(a6, a8)], select=[a6, b6, a8, b8], build=[right])
+   :  +- HashJoin(joinType=[InnerJoin], where=[=(a6, a8)], select=[a6, b6, a8, b8], build=[left])
    :     :- Exchange(distribution=[hash[a6]])
    :     :  +- Calc(select=[a6, b6], where=[IS NOT NULL(a6)])
    :     :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T6, source: [TestTableSource(a6, b6)]]], fields=[a6, b6])
@@ -684,7 +684,7 @@ LogicalProject(a6=[$0], b6=[$1], a7=[$2], b7=[$3], a8=[$4], b8=[$5])
 Calc(select=[a6, b6, a7, b7, a8, b8])
 +- HashJoin(joinType=[InnerJoin], where=[=(b6, b7)], select=[a6, b6, a8, b8, a7, b7], build=[right])
    :- Exchange(distribution=[hash[b6]])
-   :  +- HashJoin(joinType=[InnerJoin], where=[=(a6, a8)], select=[a6, b6, a8, b8], build=[right])
+   :  +- HashJoin(joinType=[InnerJoin], where=[=(a6, a8)], select=[a6, b6, a8, b8], build=[left])
    :     :- Exchange(distribution=[hash[a6]])
    :     :  +- Calc(select=[a6, b6], where=[IS NOT NULL(a6)])
    :     :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T6, source: [TestTableSource(a6, b6)]]], fields=[a6, b6])
@@ -873,7 +873,7 @@ Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testInnerAndRightOuterJoin[isBushyJoinReorder=false]">
+  <TestCase name="testInnerAndRightOuterJoin[isBushyJoinReorder=true]">
     <Resource name="sql">
       <![CDATA[
 SELECT * FROM T1
@@ -900,24 +900,24 @@ LogicalProject(a1=[$0], b1=[$1], c1=[$2], a2=[$3], b2=[$4], c2=[$5], a3=[$6], b3
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
-+- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a1, b1, c1, a2, b2, c2, a5, b5, c5, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
-   :- HashJoin(joinType=[InnerJoin], where=[=(a2, a4)], select=[a1, b1, c1, a2, b2, c2, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
-   :  :- HashJoin(joinType=[RightOuterJoin], where=[=(a1, a2)], select=[a1, b1, c1, a2, b2, c2], build=[right])
-   :  :  :- Exchange(distribution=[hash[a1]])
-   :  :  :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
++- HashJoin(joinType=[LeftOuterJoin], where=[=(a1, a2)], select=[a4, b4, c4, a5, b5, c5, a2, b2, c2, a3, b3, c3, a1, b1, c1], build=[right])
+   :- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a4, b4, c4, a5, b5, c5, a2, b2, c2, a3, b3, c3], isBroadcast=[true], build=[right])
+   :  :- HashJoin(joinType=[InnerJoin], where=[=(a2, a4)], select=[a4, b4, c4, a5, b5, c5, a2, b2, c2], isBroadcast=[true], build=[left])
+   :  :  :- Exchange(distribution=[broadcast])
+   :  :  :  +- HashJoin(joinType=[InnerJoin], where=[=(a4, a5)], select=[a4, b4, c4, a5, b5, c5], isBroadcast=[true], build=[left])
+   :  :  :     :- Exchange(distribution=[broadcast])
+   :  :  :     :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
+   :  :  :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
    :  :  +- Exchange(distribution=[hash[a2]])
    :  :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
    :  +- Exchange(distribution=[broadcast])
-   :     +- HashJoin(joinType=[InnerJoin], where=[=(a4, a5)], select=[a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
-   :        :- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
-   :        +- Exchange(distribution=[broadcast])
-   :           +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
-   +- Exchange(distribution=[broadcast])
-      +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
+   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
+   +- Exchange(distribution=[hash[a1]])
+      +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testInnerAndRightOuterJoin[isBushyJoinReorder=true]">
+  <TestCase name="testInnerAndRightOuterJoin[isBushyJoinReorder=false]">
     <Resource name="sql">
       <![CDATA[
 SELECT * FROM T1
@@ -944,20 +944,20 @@ LogicalProject(a1=[$0], b1=[$1], c1=[$2], a2=[$3], b2=[$4], c2=[$5], a3=[$6], b3
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
-+- HashJoin(joinType=[LeftOuterJoin], where=[=(a1, a2)], select=[a4, b4, c4, a5, b5, c5, a2, b2, c2, a3, b3, c3, a1, b1, c1], build=[right])
-   :- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a4, b4, c4, a5, b5, c5, a2, b2, c2, a3, b3, c3], isBroadcast=[true], build=[right])
-   :  :- HashJoin(joinType=[InnerJoin], where=[=(a2, a4)], select=[a4, b4, c4, a5, b5, c5, a2, b2, c2], isBroadcast=[true], build=[left])
-   :  :  :- Exchange(distribution=[broadcast])
-   :  :  :  +- HashJoin(joinType=[InnerJoin], where=[=(a4, a5)], select=[a4, b4, c4, a5, b5, c5], isBroadcast=[true], build=[left])
-   :  :  :     :- Exchange(distribution=[broadcast])
-   :  :  :     :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
-   :  :  :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
++- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a1, b1, c1, a2, b2, c2, a5, b5, c5, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
+   :- HashJoin(joinType=[InnerJoin], where=[=(a2, a4)], select=[a1, b1, c1, a2, b2, c2, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
+   :  :- HashJoin(joinType=[RightOuterJoin], where=[=(a1, a2)], select=[a1, b1, c1, a2, b2, c2], build=[right])
+   :  :  :- Exchange(distribution=[hash[a1]])
+   :  :  :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
    :  :  +- Exchange(distribution=[hash[a2]])
    :  :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
    :  +- Exchange(distribution=[broadcast])
-   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
-   +- Exchange(distribution=[hash[a1]])
-      +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
+   :     +- HashJoin(joinType=[InnerJoin], where=[=(a4, a5)], select=[a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
+   :        :- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
+   :        +- Exchange(distribution=[broadcast])
+   :           +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
+   +- Exchange(distribution=[broadcast])
+      +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
 ]]>
     </Resource>
   </TestCase>
@@ -1559,7 +1559,7 @@ HashJoin(joinType=[InnerJoin], where=[=(b2, b4)], select=[a1, b1, c1, a2, b2, c2
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testJoinWithFilter[isBushyJoinReorder=false]">
+  <TestCase name="testJoinWithFilter[isBushyJoinReorder=true]">
     <Resource name="sql">
       <![CDATA[
 WITH V1 AS (SELECT * FROM T1 JOIN T2 ON a1 = a2 WHERE b1 * b2 > 10),
@@ -1593,24 +1593,24 @@ LogicalProject(a4=[$0], b4=[$1], c4=[$2], a1=[$3], b1=[$4], c1=[$5], a2=[$6], b2
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a4, b4, c4, a1, b1, c1, a2, b2, c2, a3, b3, c3, a5, b5, c5])
-+- HashJoin(joinType=[InnerJoin], where=[AND(<(*(b1, b3), 2000), =(a2, a3))], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
-   :- HashJoin(joinType=[InnerJoin], where=[AND(>(+(b2, b4), 100), >(*(b1, b2), 10), =(a2, a4))], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
-   :  :- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
-   :  +- Exchange(distribution=[broadcast])
-   :     +- HashJoin(joinType=[InnerJoin], where=[=(a1, a4)], select=[a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
-   :        :- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
-   :        +- Exchange(distribution=[broadcast])
-   :           +- HashJoin(joinType=[InnerJoin], where=[=(a4, a5)], select=[a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
-   :              :- Calc(select=[a5, b5, c5], where=[<(b5, 15)])
-   :              :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
-   :              +- Exchange(distribution=[broadcast])
-   :                 +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
-   +- Exchange(distribution=[broadcast])
-      +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
++- HashJoin(joinType=[InnerJoin], where=[AND(>(+(b2, b4), 100), =(a2, a3), <(*(b1, b3), 2000))], select=[a4, b4, c4, a5, b5, c5, a3, b3, c3, a1, b1, c1, a2, b2, c2], isBroadcast=[true], build=[left])
+   :- Exchange(distribution=[broadcast])
+   :  +- HashJoin(joinType=[InnerJoin], where=[=(a3, a4)], select=[a4, b4, c4, a5, b5, c5, a3, b3, c3], isBroadcast=[true], build=[left])
+   :     :- Exchange(distribution=[broadcast])
+   :     :  +- HashJoin(joinType=[InnerJoin], where=[=(a4, a5)], select=[a4, b4, c4, a5, b5, c5], isBroadcast=[true], build=[left])
+   :     :     :- Exchange(distribution=[broadcast])
+   :     :     :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
+   :     :     +- Calc(select=[a5, b5, c5], where=[<(b5, 15)])
+   :     :        +- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
+   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
+   +- HashJoin(joinType=[InnerJoin], where=[AND(=(a1, a2), >(*(b1, b2), 10))], select=[a1, b1, c1, a2, b2, c2], isBroadcast=[true], build=[right])
+      :- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
+      +- Exchange(distribution=[broadcast])
+         +- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testJoinWithFilter[isBushyJoinReorder=true]">
+  <TestCase name="testJoinWithFilter[isBushyJoinReorder=false]">
     <Resource name="sql">
       <![CDATA[
 WITH V1 AS (SELECT * FROM T1 JOIN T2 ON a1 = a2 WHERE b1 * b2 > 10),
@@ -1644,24 +1644,24 @@ LogicalProject(a4=[$0], b4=[$1], c4=[$2], a1=[$3], b1=[$4], c1=[$5], a2=[$6], b2
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a4, b4, c4, a1, b1, c1, a2, b2, c2, a3, b3, c3, a5, b5, c5])
-+- HashJoin(joinType=[InnerJoin], where=[AND(>(+(b2, b4), 100), =(a2, a3), <(*(b1, b3), 2000))], select=[a4, b4, c4, a5, b5, c5, a3, b3, c3, a1, b1, c1, a2, b2, c2], isBroadcast=[true], build=[left])
-   :- Exchange(distribution=[broadcast])
-   :  +- HashJoin(joinType=[InnerJoin], where=[=(a3, a4)], select=[a4, b4, c4, a5, b5, c5, a3, b3, c3], isBroadcast=[true], build=[left])
-   :     :- Exchange(distribution=[broadcast])
-   :     :  +- HashJoin(joinType=[InnerJoin], where=[=(a4, a5)], select=[a4, b4, c4, a5, b5, c5], isBroadcast=[true], build=[left])
-   :     :     :- Exchange(distribution=[broadcast])
-   :     :     :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
-   :     :     +- Calc(select=[a5, b5, c5], where=[<(b5, 15)])
-   :     :        +- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
-   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
-   +- HashJoin(joinType=[InnerJoin], where=[AND(=(a1, a2), >(*(b1, b2), 10))], select=[a1, b1, c1, a2, b2, c2], isBroadcast=[true], build=[right])
-      :- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
-      +- Exchange(distribution=[broadcast])
-         +- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
++- HashJoin(joinType=[InnerJoin], where=[AND(<(*(b1, b3), 2000), =(a2, a3))], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
+   :- HashJoin(joinType=[InnerJoin], where=[AND(>(+(b2, b4), 100), >(*(b1, b2), 10), =(a2, a4))], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
+   :  :- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
+   :  +- Exchange(distribution=[broadcast])
+   :     +- HashJoin(joinType=[InnerJoin], where=[=(a1, a4)], select=[a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
+   :        :- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
+   :        +- Exchange(distribution=[broadcast])
+   :           +- HashJoin(joinType=[InnerJoin], where=[=(a4, a5)], select=[a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
+   :              :- Calc(select=[a5, b5, c5], where=[<(b5, 15)])
+   :              :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
+   :              +- Exchange(distribution=[broadcast])
+   :                 +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
+   +- Exchange(distribution=[broadcast])
+      +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testJoinWithProject[isBushyJoinReorder=false]">
+  <TestCase name="testJoinWithProject[isBushyJoinReorder=true]">
     <Resource name="sql">
       <![CDATA[
 WITH V1 AS (SELECT b1, a1, a2, c2 FROM T1 JOIN T2 ON a1 = a2),
@@ -1714,7 +1714,7 @@ HashJoin(joinType=[InnerJoin], where=[=(a4, a5)], select=[a3, b1, a1, c2, c3, a4
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testJoinWithProject[isBushyJoinReorder=true]">
+  <TestCase name="testJoinWithProject[isBushyJoinReorder=false]">
     <Resource name="sql">
       <![CDATA[
 WITH V1 AS (SELECT b1, a1, a2, c2 FROM T1 JOIN T2 ON a1 = a2),
@@ -1941,47 +1941,6 @@ Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
          :        +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
          +- Exchange(distribution=[broadcast])
             +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testStarJoinCondition1[isBushyJoinReorder=false]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT * FROM T1, T2, T3, T4, T5
-WHERE a1 = a2 AND a1 = a3 AND a1 = a4 AND a1 = a5
-         ]]>
-    </Resource>
-    <Resource name="ast">
-      <![CDATA[
-LogicalProject(a1=[$0], b1=[$1], c1=[$2], a2=[$3], b2=[$4], c2=[$5], a3=[$6], b3=[$7], c3=[$8], a4=[$9], b4=[$10], c4=[$11], a5=[$12], b5=[$13], c5=[$14])
-+- LogicalFilter(condition=[AND(=($0, $3), =($0, $6), =($0, $9), =($0, $12))])
-   +- LogicalJoin(condition=[true], joinType=[inner])
-      :- LogicalJoin(condition=[true], joinType=[inner])
-      :  :- LogicalJoin(condition=[true], joinType=[inner])
-      :  :  :- LogicalJoin(condition=[true], joinType=[inner])
-      :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]])
-      :  :  :  +- LogicalTableScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]])
-      :  :  +- LogicalTableScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]])
-      :  +- LogicalTableScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]])
-      +- LogicalTableScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]])
-]]>
-    </Resource>
-    <Resource name="optimized rel plan">
-      <![CDATA[
-Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
-+- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
-   :- HashJoin(joinType=[InnerJoin], where=[=(a2, a4)], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
-   :  :- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
-   :  +- Exchange(distribution=[broadcast])
-   :     +- HashJoin(joinType=[InnerJoin], where=[=(a1, a4)], select=[a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
-   :        :- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
-   :        +- Exchange(distribution=[broadcast])
-   :           +- HashJoin(joinType=[InnerJoin], where=[=(a5, a4)], select=[a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
-   :              :- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
-   :              +- Exchange(distribution=[broadcast])
-   :                 +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
-   +- Exchange(distribution=[broadcast])
-      +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
 ]]>
     </Resource>
   </TestCase>
@@ -2026,17 +1985,17 @@ Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testStarJoinCondition2[isBushyJoinReorder=false]">
+  <TestCase name="testStarJoinCondition1[isBushyJoinReorder=false]">
     <Resource name="sql">
       <![CDATA[
 SELECT * FROM T1, T2, T3, T4, T5
-WHERE b1 = b2 AND b1 = b3 AND b1 = b4 AND b1 = b5
+WHERE a1 = a2 AND a1 = a3 AND a1 = a4 AND a1 = a5
          ]]>
     </Resource>
     <Resource name="ast">
       <![CDATA[
 LogicalProject(a1=[$0], b1=[$1], c1=[$2], a2=[$3], b2=[$4], c2=[$5], a3=[$6], b3=[$7], c3=[$8], a4=[$9], b4=[$10], c4=[$11], a5=[$12], b5=[$13], c5=[$14])
-+- LogicalFilter(condition=[AND(=($1, $4), =($1, $7), =($1, $10), =($1, $13))])
++- LogicalFilter(condition=[AND(=($0, $3), =($0, $6), =($0, $9), =($0, $12))])
    +- LogicalJoin(condition=[true], joinType=[inner])
       :- LogicalJoin(condition=[true], joinType=[inner])
       :  :- LogicalJoin(condition=[true], joinType=[inner])
@@ -2051,18 +2010,17 @@ LogicalProject(a1=[$0], b1=[$1], c1=[$2], a2=[$3], b2=[$4], c2=[$5], a3=[$6], b3
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
-+- HashJoin(joinType=[InnerJoin], where=[=(b1, b3)], select=[a1, b1, c1, a5, b5, c5, a2, b2, c2, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
-   :- HashJoin(joinType=[InnerJoin], where=[=(b1, b4)], select=[a1, b1, c1, a5, b5, c5, a2, b2, c2, a4, b4, c4], build=[left])
-   :  :- Exchange(distribution=[hash[b1]])
-   :  :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
-   :  +- Exchange(distribution=[hash[b4]])
-   :     +- HashJoin(joinType=[InnerJoin], where=[=(b5, b4)], select=[a5, b5, c5, a2, b2, c2, a4, b4, c4], isBroadcast=[true], build=[right])
-   :        :- HashJoin(joinType=[InnerJoin], where=[=(b5, b2)], select=[a5, b5, c5, a2, b2, c2], isBroadcast=[true], build=[right])
-   :        :  :- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
-   :        :  +- Exchange(distribution=[broadcast])
-   :        :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
++- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
+   :- HashJoin(joinType=[InnerJoin], where=[=(a2, a4)], select=[a2, b2, c2, a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
+   :  :- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
+   :  +- Exchange(distribution=[broadcast])
+   :     +- HashJoin(joinType=[InnerJoin], where=[=(a1, a4)], select=[a1, b1, c1, a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
+   :        :- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
    :        +- Exchange(distribution=[broadcast])
-   :           +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
+   :           +- HashJoin(joinType=[InnerJoin], where=[=(a5, a4)], select=[a5, b5, c5, a4, b4, c4], isBroadcast=[true], build=[right])
+   :              :- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
+   :              +- Exchange(distribution=[broadcast])
+   :                 +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
    +- Exchange(distribution=[broadcast])
       +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
 ]]>
@@ -2107,6 +2065,48 @@ Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
    +- Exchange(distribution=[hash[b5]])
       +- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testStarJoinCondition2[isBushyJoinReorder=false]">
+    <Resource name="sql">
+      <![CDATA[
+SELECT * FROM T1, T2, T3, T4, T5
+WHERE b1 = b2 AND b1 = b3 AND b1 = b4 AND b1 = b5
+         ]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(a1=[$0], b1=[$1], c1=[$2], a2=[$3], b2=[$4], c2=[$5], a3=[$6], b3=[$7], c3=[$8], a4=[$9], b4=[$10], c4=[$11], a5=[$12], b5=[$13], c5=[$14])
++- LogicalFilter(condition=[AND(=($1, $4), =($1, $7), =($1, $10), =($1, $13))])
+   +- LogicalJoin(condition=[true], joinType=[inner])
+      :- LogicalJoin(condition=[true], joinType=[inner])
+      :  :- LogicalJoin(condition=[true], joinType=[inner])
+      :  :  :- LogicalJoin(condition=[true], joinType=[inner])
+      :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]])
+      :  :  :  +- LogicalTableScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]])
+      :  :  +- LogicalTableScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]])
+      :  +- LogicalTableScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]])
+      +- LogicalTableScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+Calc(select=[a1, b1, c1, a2, b2, c2, a3, b3, c3, a4, b4, c4, a5, b5, c5])
++- HashJoin(joinType=[InnerJoin], where=[=(b1, b3)], select=[a1, b1, c1, a5, b5, c5, a2, b2, c2, a4, b4, c4, a3, b3, c3], isBroadcast=[true], build=[right])
+   :- HashJoin(joinType=[InnerJoin], where=[=(b1, b4)], select=[a1, b1, c1, a5, b5, c5, a2, b2, c2, a4, b4, c4], build=[left])
+   :  :- Exchange(distribution=[hash[b1]])
+   :  :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, T1, source: [TestTableSource(a1, b1, c1)]]], fields=[a1, b1, c1])
+   :  +- Exchange(distribution=[hash[b4]])
+   :     +- HashJoin(joinType=[InnerJoin], where=[=(b5, b4)], select=[a5, b5, c5, a2, b2, c2, a4, b4, c4], isBroadcast=[true], build=[right])
+   :        :- HashJoin(joinType=[InnerJoin], where=[=(b5, b2)], select=[a5, b5, c5, a2, b2, c2], isBroadcast=[true], build=[right])
+   :        :  :- LegacyTableSourceScan(table=[[default_catalog, default_database, T5, source: [TestTableSource(a5, b5, c5)]]], fields=[a5, b5, c5])
+   :        :  +- Exchange(distribution=[broadcast])
+   :        :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T2, source: [TestTableSource(a2, b2, c2)]]], fields=[a2, b2, c2])
+   :        +- Exchange(distribution=[broadcast])
+   :           +- LegacyTableSourceScan(table=[[default_catalog, default_database, T4, source: [TestTableSource(a4, b4, c4)]]], fields=[a4, b4, c4])
+   +- Exchange(distribution=[broadcast])
+      +- LegacyTableSourceScan(table=[[default_catalog, default_database, T3, source: [TestTableSource(a3, b3, c3)]]], fields=[a3, b3, c3])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SemiAntiJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SemiAntiJoinTest.xml
index 8fcc6e99bbc..1b4724d477f 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SemiAntiJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SemiAntiJoinTest.xml
@@ -1495,39 +1495,6 @@ HashJoin(joinType=[LeftSemiJoin], where=[((a = $0) AND (b = $1))], select=[a, b,
                   +- OverAggregate(window#0=[MAX(d) AS w0$o0 RANG BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], select=[d, e, f, w0$o0])
                      +- Exchange(distribution=[single])
                         +- LegacyTableSourceScan(table=[[default_catalog, default_database, r, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testNotSimplifyJoinConditionWithSameDigest">
-    <Resource name="sql">
-      <![CDATA[
-SELECT a
-FROM l
-WHERE c NOT IN (
-    SELECT f FROM r WHERE f = c)
-]]>
-    </Resource>
-    <Resource name="ast">
-      <![CDATA[
-LogicalProject(a=[$0])
-+- LogicalFilter(condition=[NOT(IN($2, {
-LogicalProject(f=[$2])
-  LogicalFilter(condition=[=($2, $cor0.c)])
-    LogicalTableScan(table=[[default_catalog, default_database, r, source: [TestTableSource(d, e, f)]]])
-}))], variablesSet=[[$cor0]])
-   +- LogicalTableScan(table=[[default_catalog, default_database, l, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="optimized rel plan">
-      <![CDATA[
-Calc(select=[a])
-+- HashJoin(joinType=[LeftAntiJoin], where=[AND(OR(IS NULL(c), IS NULL(f), =(c, f)), =(f, c))], select=[a, c], build=[right])
-   :- Exchange(distribution=[hash[c]])
-   :  +- Calc(select=[a, c])
-   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, l, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-   +- Exchange(distribution=[hash[f]])
-      +- Calc(select=[f])
-         +- LegacyTableSourceScan(table=[[default_catalog, default_database, r, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
 ]]>
     </Resource>
   </TestCase>
@@ -2043,7 +2010,7 @@ NestedLoopJoin(joinType=[LeftAntiJoin], where=[(a IS NULL OR d IS NULL OR (a = d
 :- LegacyTableSourceScan(table=[[default_catalog, default_database, l, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
 +- Exchange(distribution=[broadcast])
    +- Calc(select=[d])
-      +- HashJoin(joinType=[LeftAntiJoin], where=[((e IS NULL OR j IS NULL OR (e = j)) AND (i = d))], select=[d, e], build=[left])
+      +- HashJoin(joinType=[LeftAntiJoin], where=[((e IS NULL OR j IS NULL OR (e = j)) AND (i = d))], select=[d, e], build=[right])
          :- Exchange(distribution=[hash[d]])
          :  +- Calc(select=[d, e])
          :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, r, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
@@ -2374,7 +2341,7 @@ LogicalProject(d=[$0], f=[$2])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[LeftAntiJoin], where=[((a IS NULL OR d IS NULL OR (a = d)) AND (c IS NULL OR f IS NULL OR (c = f)) AND (b = e))], select=[a, b, c], build=[left])
+HashJoin(joinType=[LeftAntiJoin], where=[((a IS NULL OR d IS NULL OR (a = d)) AND (c IS NULL OR f IS NULL OR (c = f)) AND (b = e))], select=[a, b, c], build=[right])
 :- Exchange(distribution=[hash[b]])
 :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, l, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
 +- Exchange(distribution=[hash[e]])
@@ -2681,6 +2648,39 @@ Calc(select=[a, b, c])
    +- Exchange(distribution=[broadcast])
       +- Calc(select=[d])
          +- LegacyTableSourceScan(table=[[default_catalog, default_database, r, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testNotSimplifyJoinConditionWithSameDigest">
+    <Resource name="sql">
+      <![CDATA[
+SELECT a
+FROM l
+WHERE c NOT IN (
+    SELECT f FROM r WHERE f = c)
+]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(a=[$0])
++- LogicalFilter(condition=[NOT(IN($2, {
+LogicalProject(f=[$2])
+  LogicalFilter(condition=[=($2, $cor0.c)])
+    LogicalTableScan(table=[[default_catalog, default_database, r, source: [TestTableSource(d, e, f)]]])
+}))], variablesSet=[[$cor0]])
+   +- LogicalTableScan(table=[[default_catalog, default_database, l, source: [TestTableSource(a, b, c)]]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+Calc(select=[a])
++- HashJoin(joinType=[LeftAntiJoin], where=[AND(OR(IS NULL(c), IS NULL(f), =(c, f)), =(f, c))], select=[a, c], build=[right])
+   :- Exchange(distribution=[hash[c]])
+   :  +- Calc(select=[a, c])
+   :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, l, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
+   +- Exchange(distribution=[hash[f]])
+      +- Calc(select=[f])
+         +- LegacyTableSourceScan(table=[[default_catalog, default_database, r, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashJoinTest.xml
index ec64f44eb0b..1b14167bace 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashJoinTest.xml
@@ -31,7 +31,7 @@ LogicalProject(c=[$7], g=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, g])
-+- HashJoin(joinType=[FullOuterJoin], where=[((a = d) AND (d < 2))], select=[d, g, a, c], build=[right])
++- HashJoin(joinType=[FullOuterJoin], where=[((a = d) AND (d < 2))], select=[d, g, a, c], build=[left])
    :- Exchange(distribution=[hash[d]])
    :  +- Calc(select=[d, g])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable2, source: [TestTableSource(d, e, f, g, h)]]], fields=[d, e, f, g, h])
@@ -78,7 +78,7 @@ LogicalProject(c=[$2], g=[$6])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, g])
-+- HashJoin(joinType=[FullOuterJoin], where=[(b = e)], select=[b, c, e, g], build=[right])
++- HashJoin(joinType=[FullOuterJoin], where=[(b = e)], select=[b, c, e, g], build=[left])
    :- Exchange(distribution=[hash[b]])
    :  +- Calc(select=[b, c])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -107,7 +107,7 @@ LogicalProject(a=[COALESCE($0, $3)], b=[$1], c=[$2], b0=[$4], c0=[$5])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[COALESCE(a, a0) AS a, b, c, b0, c0])
-+- HashJoin(joinType=[FullOuterJoin], where=[(a = a0)], select=[a, b, c, a0, b0, c0], build=[right])
++- HashJoin(joinType=[FullOuterJoin], where=[(a = a0)], select=[a, b, c, a0, b0, c0], build=[left])
    :- Exchange(distribution=[hash[a]])
    :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
    +- Exchange(distribution=[hash[a]])
@@ -130,7 +130,7 @@ LogicalProject(c=[$7], g=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, g])
-+- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[d, g, a, c], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[d, g, a, c], build=[left])
    :- Exchange(distribution=[hash[d]])
    :  +- Calc(select=[d, g], where=[(d < 2)])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable2, source: [TestTableSource(d, e, f, g, h)]]], fields=[d, e, f, g, h])
@@ -202,7 +202,7 @@ LogicalProject(c=[$2], g=[$6])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, g])
-+- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, c, d, g], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, c, d, g], build=[left])
    :- Exchange(distribution=[hash[a]])
    :  +- Calc(select=[a, c])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -228,7 +228,7 @@ LogicalProject(c=[$7], g=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, g])
-+- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[d, g, a, c], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[(a = d)], select=[d, g, a, c], build=[left])
    :- Exchange(distribution=[hash[d]])
    :  +- Calc(select=[d, g], where=[(d < 2)])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable2, source: [TestTableSource(d, e, f, g, h)]]], fields=[d, e, f, g, h])
@@ -264,7 +264,7 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, b, CAST(2 AS INTEGER) AS d, e])
-+- HashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], build=[left])
    :- Exchange(distribution=[hash[a, b]])
    :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
    :     +- Exchange(distribution=[hash[a]])
@@ -296,7 +296,7 @@ LogicalProject(c=[$2], g=[$6])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, g])
-+- HashJoin(joinType=[InnerJoin], where=[((b = e) AND (a = d))], select=[a, b, c, d, e, g], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[((b = e) AND (a = d))], select=[a, b, c, d, e, g], build=[left])
    :- Exchange(distribution=[hash[b, a]])
    :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
    +- Exchange(distribution=[hash[e, d]])
@@ -320,7 +320,7 @@ LogicalProject(c=[$7], g=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, g])
-+- HashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[d, e, g, a, b, c], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[d, e, g, a, b, c], build=[left])
    :- Exchange(distribution=[hash[d, e]])
    :  +- Calc(select=[d, e, g])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable2, source: [TestTableSource(d, e, f, g, h)]]], fields=[d, e, f, g, h])
@@ -402,7 +402,7 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[CAST(2 AS INTEGER) AS a, b, d, CAST(e AS BIGINT) AS e])
-+- HashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], build=[left])
    :- Exchange(distribution=[hash[a, b]])
    :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
    :     +- Exchange(distribution=[hash[a]])
@@ -469,7 +469,7 @@ LogicalProject(c=[$7], g=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, g])
-+- HashJoin(joinType=[LeftOuterJoin], where=[((a = d) AND (d < 2))], select=[d, g, a, c], build=[right])
++- HashJoin(joinType=[LeftOuterJoin], where=[((a = d) AND (d < 2))], select=[d, g, a, c], build=[left])
    :- Exchange(distribution=[hash[d]])
    :  +- Calc(select=[d, g])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable2, source: [TestTableSource(d, e, f, g, h)]]], fields=[d, e, f, g, h])
@@ -494,7 +494,7 @@ LogicalProject(c=[$2], g=[$6])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, g])
-+- HashJoin(joinType=[RightOuterJoin], where=[(b = e)], select=[b, c, e, g], build=[right])
++- HashJoin(joinType=[RightOuterJoin], where=[(b = e)], select=[b, c, e, g], build=[left])
    :- Exchange(distribution=[hash[b]])
    :  +- Calc(select=[b, c])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -529,7 +529,7 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, 1 AS b, CAST(2 AS INTEGER) AS d, 1 AS e])
-+- MultipleInput(readOrder=[1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[right])\n:- Calc(select=[a], where=[(b = 1)])\n:  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])\n:     +- [#1] Exchange(distribution=[hash[a]])\n+- Calc(select=[d], where=[(e = 1)])\n   +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])\n      +- [#2] Exchange(distribution=[hash[d]])\n])
++- MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])\n:- Calc(select=[a], where=[(b = 1)])\n:  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])\n:     +- [#1] Exchange(distribution=[hash[a]])\n+- Calc(select=[d], where=[(e = 1)])\n   +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])\n      +- [#2] Exchange(distribution=[hash[d]])\n])
    :- Exchange(distribution=[hash[a]])
    :  +- LocalHashAggregate(groupBy=[a], select=[a, Partial_COUNT(b) AS count$0])
    :     +- Calc(select=[CAST(2 AS INTEGER) AS a, b], where=[(a = 2)])
@@ -638,7 +638,7 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, CAST(b AS BIGINT) AS b, CAST(2 AS INTEGER) AS d, e])
-+- HashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], build=[left])
    :- Exchange(distribution=[hash[a, b]])
    :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
    :     +- Exchange(distribution=[hash[a]])
@@ -705,7 +705,7 @@ LogicalProject(c=[$2], g=[$6])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, g])
-+- HashJoin(joinType=[LeftOuterJoin], where=[(b = e)], select=[b, c, e, g], build=[right])
++- HashJoin(joinType=[LeftOuterJoin], where=[(b = e)], select=[b, c, e, g], build=[left])
    :- Exchange(distribution=[hash[b]])
    :  +- Calc(select=[b, c])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashSemiAntiJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashSemiAntiJoinTest.xml
index 0f79f0406f5..75bc9b55c0b 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashSemiAntiJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashSemiAntiJoinTest.xml
@@ -2024,7 +2024,7 @@ LogicalProject(d=[$0], f=[$2])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[LeftAntiJoin], where=[((a IS NULL OR d IS NULL OR (a = d)) AND (c IS NULL OR f IS NULL OR (c = f)) AND (b = e))], select=[a, b, c], build=[left])
+HashJoin(joinType=[LeftAntiJoin], where=[((a IS NULL OR d IS NULL OR (a = d)) AND (c IS NULL OR f IS NULL OR (c = f)) AND (b = e))], select=[a, b, c], build=[right])
 :- Exchange(distribution=[hash[b]])
 :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, l, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
 +- Exchange(distribution=[hash[e]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/table/JoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/table/JoinTest.xml
index 1d21ae762ec..ea214042a2a 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/table/JoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/table/JoinTest.xml
@@ -29,7 +29,7 @@ LogicalFilter(condition=[>=($0, 0)])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[*org.apache.flink.table.planner.plan.batch.table.JoinTest$Merger$*(c, *org.apache.flink.table.planner.plan.batch.table.JoinTest$Merger$*(c, f)) AS c1], where=[(*org.apache.flink.table.planner.plan.batch.table.JoinTest$Merger$*(c, *org.apache.flink.table.planner.plan.batch.table.JoinTest$Merger$*(c, f)) >= 0)])
-+- HashJoin(joinType=[LeftOuterJoin], where=[(b = e)], select=[b, c, e, f], build=[right])
++- HashJoin(joinType=[LeftOuterJoin], where=[(b = e)], select=[b, c, e, f], build=[left])
    :- Exchange(distribution=[hash[b]])
    :  +- Calc(select=[b, c])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, Table1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -224,7 +224,7 @@ LogicalProject(b=[$1], x=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[b, x])
-+- HashJoin(joinType=[RightOuterJoin], where=[((a = z) AND (x < 2))], select=[a, b, x, z], build=[right])
++- HashJoin(joinType=[RightOuterJoin], where=[((a = z) AND (x < 2))], select=[a, b, x, z], build=[left])
    :- Exchange(distribution=[hash[a]])
    :  +- Calc(select=[a, b])
    :     +- LegacyTableSourceScan(table=[[default_catalog, default_database, T, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
@@ -287,7 +287,7 @@ LogicalJoin(condition=[AND(=($1, $4), =(*org.apache.flink.table.planner.plan.bat
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[((b = e) AND (*org.apache.flink.table.planner.plan.batch.table.JoinTest$Merger$*(a, d) = 10))], select=[a, b, c, d, e, f], build=[right])
+HashJoin(joinType=[InnerJoin], where=[((b = e) AND (*org.apache.flink.table.planner.plan.batch.table.JoinTest$Merger$*(a, d) = 10))], select=[a, b, c, d, e, f], build=[left])
 :- Exchange(distribution=[hash[b]])
 :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, left, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
 +- Exchange(distribution=[hash[e]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hint/OptionsHintTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hint/OptionsHintTest.xml
index c128d22e19a..93e88487fdf 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hint/OptionsHintTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hint/OptionsHintTest.xml
@@ -16,7 +16,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 -->
 <Root>
-  <TestCase name="testAppendOptions[is-bounded=true]">
+  <TestCase name="testAppendOptions[is-bounded=false]">
     <Resource name="sql">
       <![CDATA[select * from t1/*+ OPTIONS(k5='v5', 'a.b.c'='fakeVal') */]]>
     </Resource>
@@ -34,7 +34,7 @@ Calc(select=[a, b, (a + 1) AS c])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testAppendOptions[is-bounded=false]">
+  <TestCase name="testAppendOptions[is-bounded=true]">
     <Resource name="sql">
       <![CDATA[select * from t1/*+ OPTIONS(k5='v5', 'a.b.c'='fakeVal') */]]>
     </Resource>
@@ -73,7 +73,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4], f=[$5])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[right])\n:- Calc(select=[a, b, (a + 1) AS c])\n:  +- [#2] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[hash[d]])\n])
+MultipleInput(readOrder=[1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[left])\n:- Calc(select=[a, b, (a + 1) AS c])\n:  +- [#2] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[hash[d]])\n])
 :- Exchange(distribution=[hash[d]])
 :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, t2, source: [OptionsTableSource(props={d.e.f=fakeVal, k3=v3, k4=v4, k6=v6})], dynamic options: {d.e.f=fakeVal, k6=v6}]], fields=[d, e, f], hints=[[[OPTIONS options:{d.e.f=fakeVal, k6=v6}]]])
 +- Exchange(distribution=[hash[a]])
@@ -111,21 +111,33 @@ Join(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], leftInput
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testOverrideOptions[is-bounded=true]">
+  <TestCase name="testJoinWithOverriddenOptions[is-bounded=false]">
     <Resource name="sql">
-      <![CDATA[select * from t1/*+ OPTIONS(k1='#v1', k2='#v2') */]]>
+      <![CDATA[
+select * from
+t1 /*+ OPTIONS(k1='#v1', k2='#v2') */
+join
+t2 /*+ OPTIONS(k3='#v3', k4='#v4') */
+on t1.a = t2.d
+]]>
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(a=[$0], b=[$1], c=[$2])
-+- LogicalProject(a=[$0], b=[$1], c=[+($0, 1)])
-   +- LogicalTableScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v1, k2=#v2})], dynamic options: {k1=#v1, k2=#v2}]], hints=[[[OPTIONS inheritPath:[] options:{k1=#v1, k2=#v2}]]])
+LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4], f=[$5])
++- LogicalJoin(condition=[=($0, $3)], joinType=[inner])
+   :- LogicalProject(a=[$0], b=[$1], c=[+($0, 1)])
+   :  +- LogicalTableScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v1, k2=#v2})], dynamic options: {k1=#v1, k2=#v2}]], hints=[[[OPTIONS inheritPath:[] options:{k1=#v1, k2=#v2}]]])
+   +- LogicalTableScan(table=[[default_catalog, default_database, t2, source: [OptionsTableSource(props={k3=#v3, k4=#v4})], dynamic options: {k3=#v3, k4=#v4}]], hints=[[[OPTIONS inheritPath:[] options:{k3=#v3, k4=#v4}]]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, b, (a + 1) AS c])
-+- LegacyTableSourceScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v1, k2=#v2})], dynamic options: {k1=#v1, k2=#v2}]], fields=[a, b], hints=[[[OPTIONS options:{k1=#v1, k2=#v2}]]])
+Join(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
+:- Exchange(distribution=[hash[a]])
+:  +- Calc(select=[a, b, (a + 1) AS c])
+:     +- LegacyTableSourceScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v1, k2=#v2})], dynamic options: {k1=#v1, k2=#v2}]], fields=[a, b], hints=[[[OPTIONS options:{k1=#v1, k2=#v2}]]])
++- Exchange(distribution=[hash[d]])
+   +- LegacyTableSourceScan(table=[[default_catalog, default_database, t2, source: [OptionsTableSource(props={k3=#v3, k4=#v4})], dynamic options: {k3=#v3, k4=#v4}]], fields=[d, e, f], hints=[[[OPTIONS options:{k3=#v3, k4=#v4}]]])
 ]]>
     </Resource>
   </TestCase>
@@ -150,7 +162,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4], f=[$5])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[right])\n:- Calc(select=[a, b, (a + 1) AS c])\n:  +- [#2] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[hash[d]])\n])
+MultipleInput(readOrder=[1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], build=[left])\n:- Calc(select=[a, b, (a + 1) AS c])\n:  +- [#2] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[hash[d]])\n])
 :- Exchange(distribution=[hash[d]])
 :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, t2, source: [OptionsTableSource(props={k3=#v3, k4=#v4})], dynamic options: {k3=#v3, k4=#v4}]], fields=[d, e, f], hints=[[[OPTIONS options:{k3=#v3, k4=#v4}]]])
 +- Exchange(distribution=[hash[a]])
@@ -158,33 +170,30 @@ MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testJoinWithOverriddenOptions[is-bounded=false]">
+  <TestCase name="testOptionsHintInsideView[is-bounded=false]">
     <Resource name="sql">
       <![CDATA[
-select * from
-t1 /*+ OPTIONS(k1='#v1', k2='#v2') */
-join
-t2 /*+ OPTIONS(k3='#v3', k4='#v4') */
-on t1.a = t2.d
+select * from t2 join v1 on v1.a = t2.d
 ]]>
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4], f=[$5])
-+- LogicalJoin(condition=[=($0, $3)], joinType=[inner])
-   :- LogicalProject(a=[$0], b=[$1], c=[+($0, 1)])
-   :  +- LogicalTableScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v1, k2=#v2})], dynamic options: {k1=#v1, k2=#v2}]], hints=[[[OPTIONS inheritPath:[] options:{k1=#v1, k2=#v2}]]])
-   +- LogicalTableScan(table=[[default_catalog, default_database, t2, source: [OptionsTableSource(props={k3=#v3, k4=#v4})], dynamic options: {k3=#v3, k4=#v4}]], hints=[[[OPTIONS inheritPath:[] options:{k3=#v3, k4=#v4}]]])
+LogicalProject(d=[$0], e=[$1], f=[$2], a=[$3], b=[$4], c=[$5])
++- LogicalJoin(condition=[=($3, $0)], joinType=[inner])
+   :- LogicalTableScan(table=[[default_catalog, default_database, t2, source: [OptionsTableSource(props={k3=v3, k4=v4})]]])
+   +- LogicalProject(a=[$0], b=[$1], c=[$2])
+      +- LogicalProject(a=[$0], b=[$1], c=[+($0, 1)])
+         +- LogicalTableScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v111, k2=v2, k4=#v444})], dynamic options: {k1=#v111, k4=#v444}]], hints=[[[OPTIONS inheritPath:[] options:{k1=#v111, k4=#v444}]]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Join(joinType=[InnerJoin], where=[(a = d)], select=[a, b, c, d, e, f], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
-:- Exchange(distribution=[hash[a]])
-:  +- Calc(select=[a, b, (a + 1) AS c])
-:     +- LegacyTableSourceScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v1, k2=#v2})], dynamic options: {k1=#v1, k2=#v2}]], fields=[a, b], hints=[[[OPTIONS options:{k1=#v1, k2=#v2}]]])
-+- Exchange(distribution=[hash[d]])
-   +- LegacyTableSourceScan(table=[[default_catalog, default_database, t2, source: [OptionsTableSource(props={k3=#v3, k4=#v4})], dynamic options: {k3=#v3, k4=#v4}]], fields=[d, e, f], hints=[[[OPTIONS options:{k3=#v3, k4=#v4}]]])
+Join(joinType=[InnerJoin], where=[(a = d)], select=[d, e, f, a, b, c], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
+:- Exchange(distribution=[hash[d]])
+:  +- LegacyTableSourceScan(table=[[default_catalog, default_database, t2, source: [OptionsTableSource(props={k3=v3, k4=v4})]]], fields=[d, e, f])
++- Exchange(distribution=[hash[a]])
+   +- Calc(select=[a, b, (a + 1) AS c])
+      +- LegacyTableSourceScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v111, k2=v2, k4=#v444})], dynamic options: {k1=#v111, k4=#v444}]], fields=[a, b], hints=[[[OPTIONS options:{k1=#v111, k4=#v444}]]])
 ]]>
     </Resource>
   </TestCase>
@@ -206,7 +215,7 @@ LogicalProject(d=[$0], e=[$1], f=[$2], a=[$3], b=[$4], c=[$5])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-MultipleInput(readOrder=[1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[d, e, f, a, b, c], build=[right])\n:- [#1] Exchange(distribution=[hash[d]])\n+- Calc(select=[a, b, (a + 1) AS c])\n   +- [#2] Exchange(distribution=[hash[a]])\n])
+MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[d, e, f, a, b, c], build=[left])\n:- [#1] Exchange(distribution=[hash[d]])\n+- Calc(select=[a, b, (a + 1) AS c])\n   +- [#2] Exchange(distribution=[hash[a]])\n])
 :- Exchange(distribution=[hash[d]])
 :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, t2, source: [OptionsTableSource(props={k3=v3, k4=v4})]]], fields=[d, e, f])
 +- Exchange(distribution=[hash[a]])
@@ -214,7 +223,7 @@ MultipleInput(readOrder=[1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testOverrideOptions[is-bounded=false]">
+  <TestCase name="testOverrideOptions[is-bounded=true]">
     <Resource name="sql">
       <![CDATA[select * from t1/*+ OPTIONS(k1='#v1', k2='#v2') */]]>
     </Resource>
@@ -232,30 +241,21 @@ Calc(select=[a, b, (a + 1) AS c])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testOptionsHintInsideView[is-bounded=false]">
+  <TestCase name="testOverrideOptions[is-bounded=false]">
     <Resource name="sql">
-      <![CDATA[
-select * from t2 join v1 on v1.a = t2.d
-]]>
+      <![CDATA[select * from t1/*+ OPTIONS(k1='#v1', k2='#v2') */]]>
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(d=[$0], e=[$1], f=[$2], a=[$3], b=[$4], c=[$5])
-+- LogicalJoin(condition=[=($3, $0)], joinType=[inner])
-   :- LogicalTableScan(table=[[default_catalog, default_database, t2, source: [OptionsTableSource(props={k3=v3, k4=v4})]]])
-   +- LogicalProject(a=[$0], b=[$1], c=[$2])
-      +- LogicalProject(a=[$0], b=[$1], c=[+($0, 1)])
-         +- LogicalTableScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v111, k2=v2, k4=#v444})], dynamic options: {k1=#v111, k4=#v444}]], hints=[[[OPTIONS inheritPath:[] options:{k1=#v111, k4=#v444}]]])
+LogicalProject(a=[$0], b=[$1], c=[$2])
++- LogicalProject(a=[$0], b=[$1], c=[+($0, 1)])
+   +- LogicalTableScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v1, k2=#v2})], dynamic options: {k1=#v1, k2=#v2}]], hints=[[[OPTIONS inheritPath:[] options:{k1=#v1, k2=#v2}]]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Join(joinType=[InnerJoin], where=[(a = d)], select=[d, e, f, a, b, c], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
-:- Exchange(distribution=[hash[d]])
-:  +- LegacyTableSourceScan(table=[[default_catalog, default_database, t2, source: [OptionsTableSource(props={k3=v3, k4=v4})]]], fields=[d, e, f])
-+- Exchange(distribution=[hash[a]])
-   +- Calc(select=[a, b, (a + 1) AS c])
-      +- LegacyTableSourceScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v111, k2=v2, k4=#v444})], dynamic options: {k1=#v111, k4=#v444}]], fields=[a, b], hints=[[[OPTIONS options:{k1=#v111, k4=#v444}]]])
+Calc(select=[a, b, (a + 1) AS c])
++- LegacyTableSourceScan(table=[[default_catalog, default_database, t1, source: [OptionsTableSource(props={k1=#v1, k2=#v2})], dynamic options: {k1=#v1, k2=#v2}]], fields=[a, b], hints=[[[OPTIONS options:{k1=#v1, k2=#v2}]]])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/BroadcastJoinHintTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/BroadcastJoinHintTest.xml
index 2db1b869bc8..255ad29c35a 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/BroadcastJoinHintTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/BroadcastJoinHintTest.xml
@@ -588,7 +588,7 @@ LogicalProject(a1=[$0], b1=[$1], a2=[$2], b2=[$3])
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
-HashJoin(joinType=[FullOuterJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[right])
+HashJoin(joinType=[FullOuterJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[left])
 :- Exchange(distribution=[hash[a1]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, T1]], fields=[a1, b1])
 +- Exchange(distribution=[hash[a2]])
@@ -610,7 +610,7 @@ LogicalProject(a1=[$0], b1=[$1], a2=[$2], b2=[$3])
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
-HashJoin(joinType=[FullOuterJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[right])
+HashJoin(joinType=[FullOuterJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[left])
 :- Exchange(distribution=[hash[a1]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, T1]], fields=[a1, b1])
 +- Exchange(distribution=[hash[a2]])
@@ -820,7 +820,7 @@ Calc(select=[a1, b1])
                         :     :- Exchange(distribution=[broadcast])
                         :     :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
                         :     +- Calc(select=[a3])
-                        :        +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[right])
+                        :        +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[left])
                         :           :- Exchange(distribution=[hash[a2]])
                         :           :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
                         :           +- Exchange(distribution=[hash[a3]])
@@ -878,7 +878,7 @@ LogicalProject(a1=[$0], b1=[$1], a2=[$2], b2=[$3])
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
-HashJoin(joinType=[LeftOuterJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[right])
+HashJoin(joinType=[LeftOuterJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[left])
 :- Exchange(distribution=[hash[a1]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, T1]], fields=[a1, b1])
 +- Exchange(distribution=[hash[a2]])
@@ -942,7 +942,7 @@ LogicalProject(a1=[$0], b1=[$1], a2=[$2], b2=[$3])
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
-HashJoin(joinType=[RightOuterJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[right])
+HashJoin(joinType=[RightOuterJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[left])
 :- Exchange(distribution=[hash[a1]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, T1]], fields=[a1, b1])
 +- Exchange(distribution=[hash[a2]])
@@ -1109,7 +1109,7 @@ Calc(select=[a1, b1])
    :- Exchange(distribution=[broadcast])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Calc(select=[a1])
-      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
          :- Exchange(distribution=[hash[a1]])
          :  +- Calc(select=[a1])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
@@ -1153,7 +1153,7 @@ NestedLoopJoin(joinType=[LeftOuterJoin], where=[true], select=[a1, EXPR$0], buil
       +- Exchange(distribution=[single])
          +- LocalHashAggregate(select=[Partial_COUNT(*) AS count1$0])
             +- Calc(select=[0 AS $f0])
-               +- HashJoin(joinType=[InnerJoin], where=[=(a1, a3)], select=[a1, a3], build=[right])
+               +- HashJoin(joinType=[InnerJoin], where=[=(a1, a3)], select=[a1, a3], build=[left])
                   :- Exchange(distribution=[hash[a1]])
                   :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1], metadata=[]]], fields=[a1], hints=[[[ALIAS options:[T1]]]])
                   +- Exchange(distribution=[hash[a3]])
@@ -1221,7 +1221,7 @@ LogicalAggregate(group=[{}], EXPR$0=[COUNT()])
       <![CDATA[
 NestedLoopJoin(joinType=[LeftOuterJoin], where=[true], select=[a1, $f2], build=[right])
 :- Calc(select=[a1])
-:  +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+:  +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
 :     :- Exchange(distribution=[hash[a1]])
 :     :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1], metadata=[]]], fields=[a1])
 :     +- Exchange(distribution=[hash[a2]])
@@ -1321,7 +1321,7 @@ Calc(select=[a1, b1])
    :- Exchange(distribution=[broadcast])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Calc(select=[a1])
-      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
          :- Exchange(distribution=[hash[a1]])
          :  +- Calc(select=[a1])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
@@ -1481,7 +1481,7 @@ LogicalProject(a1=[$0], b1=[$1], a2=[$2], b2=[$3])
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
-HashJoin(joinType=[RightOuterJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[right])
+HashJoin(joinType=[RightOuterJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[left])
 :- Exchange(distribution=[hash[a1]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, T1]], fields=[a1, b1])
 +- Exchange(distribution=[hash[a2]])
@@ -1658,7 +1658,7 @@ Calc(select=[a1, b1])
    :- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Exchange(distribution=[broadcast])
       +- Calc(select=[a1])
-         +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+         +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
             :- Exchange(distribution=[hash[a1]])
             :  +- Calc(select=[a1])
             :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/NestLoopJoinHintTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/NestLoopJoinHintTest.xml
index 0d451400b57..85579fb05b4 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/NestLoopJoinHintTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/NestLoopJoinHintTest.xml
@@ -474,7 +474,7 @@ LogicalProject(a1=[$0], b1=[$1], a2=[$2], b2=[$3])
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[right])
+HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[left])
 :- Exchange(distribution=[hash[a1]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, T1]], fields=[a1, b1])
 +- Exchange(distribution=[hash[a2]])
@@ -820,7 +820,7 @@ Calc(select=[a1, b1])
                         :        :- Exchange(distribution=[broadcast])
                         :        :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
                         :        +- Calc(select=[a3])
-                        :           +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[right])
+                        :           +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[left])
                         :              :- Exchange(distribution=[hash[a2]])
                         :              :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
                         :              +- Exchange(distribution=[hash[a3]])
@@ -1106,7 +1106,7 @@ Calc(select=[a1, b1])
    :- Exchange(distribution=[broadcast])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Calc(select=[a1])
-      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
          :- Exchange(distribution=[hash[a1]])
          :  +- Calc(select=[a1])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
@@ -1150,7 +1150,7 @@ NestedLoopJoin(joinType=[LeftOuterJoin], where=[true], select=[a1, EXPR$0], buil
       +- Exchange(distribution=[single])
          +- LocalHashAggregate(select=[Partial_COUNT(*) AS count1$0])
             +- Calc(select=[0 AS $f0])
-               +- HashJoin(joinType=[InnerJoin], where=[=(a1, a3)], select=[a1, a3], build=[right])
+               +- HashJoin(joinType=[InnerJoin], where=[=(a1, a3)], select=[a1, a3], build=[left])
                   :- Exchange(distribution=[hash[a1]])
                   :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1], metadata=[]]], fields=[a1], hints=[[[ALIAS options:[T1]]]])
                   +- Exchange(distribution=[hash[a3]])
@@ -1218,7 +1218,7 @@ LogicalAggregate(group=[{}], EXPR$0=[COUNT()])
       <![CDATA[
 NestedLoopJoin(joinType=[LeftOuterJoin], where=[true], select=[a1, $f2], build=[right])
 :- Calc(select=[a1])
-:  +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+:  +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
 :     :- Exchange(distribution=[hash[a1]])
 :     :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1], metadata=[]]], fields=[a1])
 :     +- Exchange(distribution=[hash[a2]])
@@ -1318,7 +1318,7 @@ Calc(select=[a1, b1])
    :- Exchange(distribution=[broadcast])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Calc(select=[a1])
-      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
          :- Exchange(distribution=[hash[a1]])
          :  +- Calc(select=[a1])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
@@ -1654,7 +1654,7 @@ Calc(select=[a1, b1])
    :- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Exchange(distribution=[broadcast])
       +- Calc(select=[a1])
-         +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+         +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
             :- Exchange(distribution=[hash[a1]])
             :  +- Calc(select=[a1])
             :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/ShuffleHashJoinHintTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/ShuffleHashJoinHintTest.xml
index 390f9e0d5af..0ac94bf4c22 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/ShuffleHashJoinHintTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/ShuffleHashJoinHintTest.xml
@@ -841,7 +841,7 @@ Calc(select=[a1, b1])
                         :     :- Exchange(distribution=[hash[a2]])
                         :     :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
                         :     +- Calc(select=[a3])
-                        :        +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[right])
+                        :        +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[left])
                         :           :- Exchange(distribution=[hash[a2]])
                         :           :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
                         :           +- Exchange(distribution=[hash[a3]])
@@ -1140,7 +1140,7 @@ Calc(select=[a1, b1])
    :- Exchange(distribution=[hash[a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Calc(select=[a1])
-      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
          :- Exchange(distribution=[hash[a1]])
          :  +- Calc(select=[a1])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
@@ -1184,7 +1184,7 @@ NestedLoopJoin(joinType=[LeftOuterJoin], where=[true], select=[a1, EXPR$0], buil
       +- Exchange(distribution=[single])
          +- LocalHashAggregate(select=[Partial_COUNT(*) AS count1$0])
             +- Calc(select=[0 AS $f0])
-               +- HashJoin(joinType=[InnerJoin], where=[=(a1, a3)], select=[a1, a3], build=[right])
+               +- HashJoin(joinType=[InnerJoin], where=[=(a1, a3)], select=[a1, a3], build=[left])
                   :- Exchange(distribution=[hash[a1]])
                   :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1], metadata=[]]], fields=[a1], hints=[[[ALIAS options:[T1]]]])
                   +- Exchange(distribution=[hash[a3]])
@@ -1252,7 +1252,7 @@ LogicalAggregate(group=[{}], EXPR$0=[COUNT()])
       <![CDATA[
 NestedLoopJoin(joinType=[LeftOuterJoin], where=[true], select=[a1, $f2], build=[right])
 :- Calc(select=[a1])
-:  +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+:  +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
 :     :- Exchange(distribution=[hash[a1]])
 :     :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1], metadata=[]]], fields=[a1])
 :     +- Exchange(distribution=[hash[a2]])
@@ -1352,7 +1352,7 @@ Calc(select=[a1, b1])
    :- Exchange(distribution=[hash[a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Calc(select=[a1])
-      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
          :- Exchange(distribution=[hash[a1]])
          :  +- Calc(select=[a1])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
@@ -1693,7 +1693,7 @@ Calc(select=[a1, b1])
    :- Exchange(distribution=[hash[a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Calc(select=[a1])
-      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
          :- Exchange(distribution=[hash[a1]])
          :  +- Calc(select=[a1])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/ShuffleMergeJoinHintTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/ShuffleMergeJoinHintTest.xml
index ceafec98d3c..d04f66495a8 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/ShuffleMergeJoinHintTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/hints/batch/ShuffleMergeJoinHintTest.xml
@@ -491,7 +491,7 @@ LogicalProject(a1=[$0], b1=[$1], a2=[$2], b2=[$3])
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[right])
+HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, b1, a2, b2], build=[left])
 :- Exchange(distribution=[hash[a1]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, T1]], fields=[a1, b1])
 +- Exchange(distribution=[hash[a2]])
@@ -841,7 +841,7 @@ Calc(select=[a1, b1])
                         :     :- Exchange(distribution=[hash[a2]])
                         :     :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
                         :     +- Calc(select=[a3])
-                        :        +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[right])
+                        :        +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[left])
                         :           :- Exchange(distribution=[hash[a2]])
                         :           :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
                         :           +- Exchange(distribution=[hash[a3]])
@@ -1140,7 +1140,7 @@ Calc(select=[a1, b1])
    :- Exchange(distribution=[hash[a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Calc(select=[a1])
-      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
          :- Exchange(distribution=[hash[a1]])
          :  +- Calc(select=[a1])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
@@ -1184,7 +1184,7 @@ NestedLoopJoin(joinType=[LeftOuterJoin], where=[true], select=[a1, EXPR$0], buil
       +- Exchange(distribution=[single])
          +- LocalHashAggregate(select=[Partial_COUNT(*) AS count1$0])
             +- Calc(select=[0 AS $f0])
-               +- HashJoin(joinType=[InnerJoin], where=[=(a1, a3)], select=[a1, a3], build=[right])
+               +- HashJoin(joinType=[InnerJoin], where=[=(a1, a3)], select=[a1, a3], build=[left])
                   :- Exchange(distribution=[hash[a1]])
                   :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1], metadata=[]]], fields=[a1], hints=[[[ALIAS options:[T1]]]])
                   +- Exchange(distribution=[hash[a3]])
@@ -1252,7 +1252,7 @@ LogicalAggregate(group=[{}], EXPR$0=[COUNT()])
       <![CDATA[
 NestedLoopJoin(joinType=[LeftOuterJoin], where=[true], select=[a1, $f2], build=[right])
 :- Calc(select=[a1])
-:  +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+:  +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
 :     :- Exchange(distribution=[hash[a1]])
 :     :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1], metadata=[]]], fields=[a1])
 :     +- Exchange(distribution=[hash[a2]])
@@ -1352,7 +1352,7 @@ Calc(select=[a1, b1])
    :- Exchange(distribution=[hash[a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Calc(select=[a1])
-      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
          :- Exchange(distribution=[hash[a1]])
          :  +- Calc(select=[a1])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
@@ -1693,7 +1693,7 @@ Calc(select=[a1, b1])
    :- Exchange(distribution=[hash[a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
    +- Calc(select=[a1])
-      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[right])
+      +- HashJoin(joinType=[InnerJoin], where=[=(a1, a2)], select=[a1, a2], build=[left])
          :- Exchange(distribution=[hash[a1]])
          :  +- Calc(select=[a1])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/nodes/exec/operator/BatchOperatorNameTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/nodes/exec/operator/BatchOperatorNameTest.xml
index bfa8c9deee9..38dfcb0ed78 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/nodes/exec/operator/BatchOperatorNameTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/nodes/exec/operator/BatchOperatorNameTest.xml
@@ -190,7 +190,7 @@ Calc(select=[EXPR$0 AS s])
 }]]>
     </Resource>
   </TestCase>
-  <TestCase name="testGroupWindowAggregate[isNameSimplifyEnabled=false]">
+  <TestCase name="testGroupWindowAggregate[isNameSimplifyEnabled=true]">
     <Resource name="explain">
       <![CDATA[== Abstract Syntax Tree ==
 LogicalProject(b=[$0], window_end=[TUMBLE_END($1)], EXPR$2=[$2])
@@ -217,15 +217,15 @@ Calc(select=[b, w$end AS window_end, EXPR$2])
 {
   "nodes" : [ {
     "id" : ,
-    "type" : "Source: TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[b, rowtime], metadata=[]]], fields=[b, rowtime])",
+    "type" : "Source: MyTable[]",
     "pact" : "Data Source",
-    "contents" : "TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[b, rowtime], metadata=[]]], fields=[b, rowtime])",
+    "contents" : "[]:TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[b, rowtime], metadata=[]]], fields=[b, rowtime])",
     "parallelism" : 1
   }, {
     "id" : ,
-    "type" : "LocalHashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Partial_COUNT(*) AS count1$0])",
+    "type" : "HashWindowAggregate[]",
     "pact" : "Operator",
-    "contents" : "LocalHashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Partial_COUNT(*) AS count1$0])",
+    "contents" : "[]:LocalHashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Partial_COUNT(*) AS count1$0])",
     "parallelism" : 1,
     "predecessors" : [ {
       "id" : ,
@@ -234,9 +234,9 @@ Calc(select=[b, w$end AS window_end, EXPR$2])
     } ]
   }, {
     "id" : ,
-    "type" : "HashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Final_COUNT(count1$0) AS EXPR$2])",
+    "type" : "HashWindowAggregate[]",
     "pact" : "Operator",
-    "contents" : "HashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Final_COUNT(count1$0) AS EXPR$2])",
+    "contents" : "[]:HashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Final_COUNT(count1$0) AS EXPR$2])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -245,9 +245,9 @@ Calc(select=[b, w$end AS window_end, EXPR$2])
     } ]
   }, {
     "id" : ,
-    "type" : "Calc(select=[b, w$end AS window_end, EXPR$2])",
+    "type" : "Calc[]",
     "pact" : "Operator",
-    "contents" : "Calc(select=[b, w$end AS window_end, EXPR$2])",
+    "contents" : "[]:Calc(select=[b, w$end AS window_end, EXPR$2])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -258,7 +258,7 @@ Calc(select=[b, w$end AS window_end, EXPR$2])
 }]]>
     </Resource>
   </TestCase>
-  <TestCase name="testGroupWindowAggregate[isNameSimplifyEnabled=true]">
+  <TestCase name="testGroupWindowAggregate[isNameSimplifyEnabled=false]">
     <Resource name="explain">
       <![CDATA[== Abstract Syntax Tree ==
 LogicalProject(b=[$0], window_end=[TUMBLE_END($1)], EXPR$2=[$2])
@@ -285,15 +285,15 @@ Calc(select=[b, w$end AS window_end, EXPR$2])
 {
   "nodes" : [ {
     "id" : ,
-    "type" : "Source: MyTable[]",
+    "type" : "Source: TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[b, rowtime], metadata=[]]], fields=[b, rowtime])",
     "pact" : "Data Source",
-    "contents" : "[]:TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[b, rowtime], metadata=[]]], fields=[b, rowtime])",
+    "contents" : "TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[b, rowtime], metadata=[]]], fields=[b, rowtime])",
     "parallelism" : 1
   }, {
     "id" : ,
-    "type" : "HashWindowAggregate[]",
+    "type" : "LocalHashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Partial_COUNT(*) AS count1$0])",
     "pact" : "Operator",
-    "contents" : "[]:LocalHashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Partial_COUNT(*) AS count1$0])",
+    "contents" : "LocalHashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Partial_COUNT(*) AS count1$0])",
     "parallelism" : 1,
     "predecessors" : [ {
       "id" : ,
@@ -302,9 +302,9 @@ Calc(select=[b, w$end AS window_end, EXPR$2])
     } ]
   }, {
     "id" : ,
-    "type" : "HashWindowAggregate[]",
+    "type" : "HashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Final_COUNT(count1$0) AS EXPR$2])",
     "pact" : "Operator",
-    "contents" : "[]:HashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Final_COUNT(count1$0) AS EXPR$2])",
+    "contents" : "HashWindowAggregate(groupBy=[b], window=[TumblingGroupWindow('w$, rowtime, 900000)], properties=[w$start, w$end, w$rowtime], select=[b, Final_COUNT(count1$0) AS EXPR$2])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -313,9 +313,9 @@ Calc(select=[b, w$end AS window_end, EXPR$2])
     } ]
   }, {
     "id" : ,
-    "type" : "Calc[]",
+    "type" : "Calc(select=[b, w$end AS window_end, EXPR$2])",
     "pact" : "Operator",
-    "contents" : "[]:Calc(select=[b, w$end AS window_end, EXPR$2])",
+    "contents" : "Calc(select=[b, w$end AS window_end, EXPR$2])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -498,14 +498,14 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], a0=[$4], b0=[$5], c0=[$6], d0=[$7
       +- LogicalTableScan(table=[[default_catalog, default_database, B]])
 
 == Optimized Physical Plan ==
-HashJoin(joinType=[InnerJoin], where=[=(a, d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])
+HashJoin(joinType=[InnerJoin], where=[=(a, d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])
 :- Exchange(distribution=[hash[a]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])
 +- Exchange(distribution=[hash[d]])
    +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[a, b, c, d])
 
 == Optimized Execution Plan ==
-HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])
 :- Exchange(distribution=[hash[a]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])
 +- Exchange(distribution=[hash[d]])
@@ -527,17 +527,17 @@ HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0,
     "parallelism" : 1
   }, {
     "id" : ,
-    "type" : "HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])",
+    "type" : "HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])",
     "pact" : "Operator",
-    "contents" : "HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])",
+    "contents" : "HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
-      "ship_strategy" : "HASH[d]",
+      "ship_strategy" : "HASH[a]",
       "side" : "second"
     }, {
       "id" : ,
-      "ship_strategy" : "HASH[a]",
+      "ship_strategy" : "HASH[d]",
       "side" : "second"
     } ]
   } ]
@@ -554,14 +554,14 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], a0=[$4], b0=[$5], c0=[$6], d0=[$7
       +- LogicalTableScan(table=[[default_catalog, default_database, B]])
 
 == Optimized Physical Plan ==
-HashJoin(joinType=[InnerJoin], where=[=(a, d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])
+HashJoin(joinType=[InnerJoin], where=[=(a, d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])
 :- Exchange(distribution=[hash[a]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])
 +- Exchange(distribution=[hash[d]])
    +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[a, b, c, d])
 
 == Optimized Execution Plan ==
-HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])
+HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])
 :- Exchange(distribution=[hash[a]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])
 +- Exchange(distribution=[hash[d]])
@@ -585,15 +585,15 @@ HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0,
     "id" : ,
     "type" : "HashJoin[]",
     "pact" : "Operator",
-    "contents" : "[]:HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])",
+    "contents" : "[]:HashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
-      "ship_strategy" : "HASH[d]",
+      "ship_strategy" : "HASH[a]",
       "side" : "second"
     }, {
       "id" : ,
-      "ship_strategy" : "HASH[a]",
+      "ship_strategy" : "HASH[d]",
       "side" : "second"
     } ]
   } ]
@@ -1083,7 +1083,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], a0=[$4], b0=[$5], c0=[$6], d0=[$7
 
 == Optimized Physical Plan ==
 HashJoin(joinType=[InnerJoin], where=[=(a, a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])
-:- HashJoin(joinType=[InnerJoin], where=[=(a, a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])
+:- HashJoin(joinType=[InnerJoin], where=[=(a, a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])
 :  :- Exchange(distribution=[hash[a]])
 :  :  +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])
 :  +- Exchange(distribution=[hash[a]])
@@ -1092,7 +1092,7 @@ HashJoin(joinType=[InnerJoin], where=[=(a, a1)], select=[a, b, c, d, a0, b0, c0,
    +- TableSourceScan(table=[[default_catalog, default_database, C]], fields=[a, b, c, d])
 
 == Optimized Execution Plan ==
-MultipleInput(readOrder=[2,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])\n:- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])\n:  :- [#2] Exchange(distribution=[hash[a]])\n:  +- [#3] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[hash[a]])\n])
+MultipleInput(readOrder=[2,0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])\n:- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])\n:  :- [#2] Exchange(distribution=[hash[a]])\n:  +- [#3] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[hash[a]])\n])
 :- Exchange(distribution=[hash[a]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, C]], fields=[a, b, c, d])
 :- Exchange(distribution=[hash[a]])
@@ -1122,9 +1122,9 @@ MultipleInput(readOrder=[2,1,0], members=[\nHashJoin(joinType=[InnerJoin], where
     "parallelism" : 1
   }, {
     "id" : ,
-    "type" : "MultipleInput(readOrder=[2,1,0], members=[\\nHashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])\\n:- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])\\n:  :- [#2] Exchange(distribution=[hash[a]])\\n:  +- [#3] Exchange(distribution=[hash[a]])\\n+- [#1] Exchange(distribution=[hash[a]])\\n])",
+    "type" : "MultipleInput(readOrder=[2,0,1], members=[\\nHashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])\\n:- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])\\n:  :- [#2] Exchange(distribution=[hash[a]])\\n:  +- [#3] Exchange(distribution=[hash[a]])\\n+- [#1] Exchange(distribution=[hash[a]])\\n])",
     "pact" : "Operator",
-    "contents" : "MultipleInput(readOrder=[2,1,0], members=[\\nHashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])\\n:- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])\\n:  :- [#2] Exchange(distribution=[hash[a]])\\n:  +- [#3] Exchange(distribution=[hash[a]])\\n+- [#1] Exchange(distribution=[hash[a]])\\n])",
+    "contents" : "MultipleInput(readOrder=[2,0,1], members=[\\nHashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])\\n:- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])\\n:  :- [#2] Exchange(distribution=[hash[a]])\\n:  +- [#3] Exchange(distribution=[hash[a]])\\n+- [#1] Exchange(distribution=[hash[a]])\\n])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -1156,7 +1156,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], a0=[$4], b0=[$5], c0=[$6], d0=[$7
 
 == Optimized Physical Plan ==
 HashJoin(joinType=[InnerJoin], where=[=(a, a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])
-:- HashJoin(joinType=[InnerJoin], where=[=(a, a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])
+:- HashJoin(joinType=[InnerJoin], where=[=(a, a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])
 :  :- Exchange(distribution=[hash[a]])
 :  :  +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])
 :  +- Exchange(distribution=[hash[a]])
@@ -1165,7 +1165,7 @@ HashJoin(joinType=[InnerJoin], where=[=(a, a1)], select=[a, b, c, d, a0, b0, c0,
    +- TableSourceScan(table=[[default_catalog, default_database, C]], fields=[a, b, c, d])
 
 == Optimized Execution Plan ==
-MultipleInput(readOrder=[2,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])\n:- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])\n:  :- [#2] Exchange(distribution=[hash[a]])\n:  +- [#3] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[hash[a]])\n])
+MultipleInput(readOrder=[2,0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])\n:- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])\n:  :- [#2] Exchange(distribution=[hash[a]])\n:  +- [#3] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[hash[a]])\n])
 :- Exchange(distribution=[hash[a]])
 :  +- TableSourceScan(table=[[default_catalog, default_database, C]], fields=[a, b, c, d])
 :- Exchange(distribution=[hash[a]])
@@ -1197,7 +1197,7 @@ MultipleInput(readOrder=[2,1,0], members=[\nHashJoin(joinType=[InnerJoin], where
     "id" : ,
     "type" : "MultipleInput[]",
     "pact" : "Operator",
-    "contents" : "[]:MultipleInput(readOrder=[2,1,0], members=[\\nHashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])\\n:- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[right])\\n:  :- [#2] Exchange(distribution=[hash[a]])\\n:  +- [#3] Exchange(distribution=[hash[a]])\\n+- [#1] Exchange(distribution=[hash[a]])\\n])",
+    "contents" : "[]:MultipleInput(readOrder=[2,0,1], members=[\\nHashJoin(joinType=[InnerJoin], where=[(a = a1)], select=[a, b, c, d, a0, b0, c0, d0, a1, b1, c1, d1], build=[left])\\n:- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, c, d, a0, b0, c0, d0], build=[left])\\n:  :- [#2] Exchange(distribution=[hash[a]])\\n:  +- [#3] Exchange(distribution=[hash[a]])\\n+- [#1] Exchange(distribution=[hash[a]])\\n])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -1458,7 +1458,7 @@ Calc(select=[b, w0$o0 AS $1])
 }]]>
     </Resource>
   </TestCase>
-  <TestCase name="testRank[isNameSimplifyEnabled=false]">
+  <TestCase name="testRank[isNameSimplifyEnabled=true]">
     <Resource name="explain">
       <![CDATA[== Abstract Syntax Tree ==
 LogicalProject(a=[$0], row_num=[$1])
@@ -1485,15 +1485,15 @@ Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])
 {
   "nodes" : [ {
     "id" : ,
-    "type" : "Source: TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, b], metadata=[]]], fields=[a, b])",
+    "type" : "Source: MyTable[]",
     "pact" : "Data Source",
-    "contents" : "TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, b], metadata=[]]], fields=[a, b])",
+    "contents" : "[]:TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, b], metadata=[]]], fields=[a, b])",
     "parallelism" : 1
   }, {
     "id" : ,
-    "type" : "Sort(orderBy=[b ASC, a ASC])",
+    "type" : "Sort[]",
     "pact" : "Operator",
-    "contents" : "Sort(orderBy=[b ASC, a ASC])",
+    "contents" : "[]:Sort(orderBy=[b ASC, a ASC])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -1502,9 +1502,9 @@ Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])
     } ]
   }, {
     "id" : ,
-    "type" : "OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[ROW_NUMBER(*) AS w0$o0 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0])",
+    "type" : "OverAggregate[]",
     "pact" : "Operator",
-    "contents" : "OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[ROW_NUMBER(*) AS w0$o0 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0])",
+    "contents" : "[]:OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[ROW_NUMBER(*) AS w0$o0 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -1513,9 +1513,9 @@ Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])
     } ]
   }, {
     "id" : ,
-    "type" : "Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])",
+    "type" : "Calc[]",
     "pact" : "Operator",
-    "contents" : "Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])",
+    "contents" : "[]:Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -1526,7 +1526,7 @@ Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])
 }]]>
     </Resource>
   </TestCase>
-  <TestCase name="testRank[isNameSimplifyEnabled=true]">
+  <TestCase name="testRank[isNameSimplifyEnabled=false]">
     <Resource name="explain">
       <![CDATA[== Abstract Syntax Tree ==
 LogicalProject(a=[$0], row_num=[$1])
@@ -1553,15 +1553,15 @@ Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])
 {
   "nodes" : [ {
     "id" : ,
-    "type" : "Source: MyTable[]",
+    "type" : "Source: TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, b], metadata=[]]], fields=[a, b])",
     "pact" : "Data Source",
-    "contents" : "[]:TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, b], metadata=[]]], fields=[a, b])",
+    "contents" : "TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, b], metadata=[]]], fields=[a, b])",
     "parallelism" : 1
   }, {
     "id" : ,
-    "type" : "Sort[]",
+    "type" : "Sort(orderBy=[b ASC, a ASC])",
     "pact" : "Operator",
-    "contents" : "[]:Sort(orderBy=[b ASC, a ASC])",
+    "contents" : "Sort(orderBy=[b ASC, a ASC])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -1570,9 +1570,9 @@ Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])
     } ]
   }, {
     "id" : ,
-    "type" : "OverAggregate[]",
+    "type" : "OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[ROW_NUMBER(*) AS w0$o0 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0])",
     "pact" : "Operator",
-    "contents" : "[]:OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[ROW_NUMBER(*) AS w0$o0 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0])",
+    "contents" : "OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[ROW_NUMBER(*) AS w0$o0 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -1581,9 +1581,9 @@ Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])
     } ]
   }, {
     "id" : ,
-    "type" : "Calc[]",
+    "type" : "Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])",
     "pact" : "Operator",
-    "contents" : "[]:Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])",
+    "contents" : "Calc(select=[a, w0$o0], where=[(w0$o0 <= a)])",
     "parallelism" : 2,
     "predecessors" : [ {
       "id" : ,
@@ -2027,6 +2027,62 @@ SortMergeJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0
       "side" : "second"
     } ]
   } ]
+}]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testSortMergeJoin[isNameSimplifyEnabled=true]">
+    <Resource name="explain">
+      <![CDATA[== Abstract Syntax Tree ==
+LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], a0=[$4], b0=[$5], c0=[$6], d0=[$7])
++- LogicalFilter(condition=[=($0, $7)])
+   +- LogicalJoin(condition=[true], joinType=[inner])
+      :- LogicalTableScan(table=[[default_catalog, default_database, A]])
+      +- LogicalTableScan(table=[[default_catalog, default_database, B]])
+
+== Optimized Physical Plan ==
+SortMergeJoin(joinType=[InnerJoin], where=[=(a, d0)], select=[a, b, c, d, a0, b0, c0, d0])
+:- Exchange(distribution=[hash[a]])
+:  +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])
++- Exchange(distribution=[hash[d]])
+   +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[a, b, c, d])
+
+== Optimized Execution Plan ==
+SortMergeJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0])
+:- Exchange(distribution=[hash[a]])
+:  +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])
++- Exchange(distribution=[hash[d]])
+   +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[a, b, c, d])
+
+== Physical Execution Plan ==
+{
+  "nodes" : [ {
+    "id" : ,
+    "type" : "Source: A[]",
+    "pact" : "Data Source",
+    "contents" : "[]:TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])",
+    "parallelism" : 1
+  }, {
+    "id" : ,
+    "type" : "Source: B[]",
+    "pact" : "Data Source",
+    "contents" : "[]:TableSourceScan(table=[[default_catalog, default_database, B]], fields=[a, b, c, d])",
+    "parallelism" : 1
+  }, {
+    "id" : ,
+    "type" : "SortMergeJoin[]",
+    "pact" : "Operator",
+    "contents" : "[]:SortMergeJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0])",
+    "parallelism" : 2,
+    "predecessors" : [ {
+      "id" : ,
+      "ship_strategy" : "HASH[a]",
+      "side" : "second"
+    }, {
+      "id" : ,
+      "ship_strategy" : "HASH[d]",
+      "side" : "second"
+    } ]
+  } ]
 }]]>
     </Resource>
   </TestCase>
@@ -2096,62 +2152,6 @@ Calc(select=[b, w$end AS window_end, EXPR$2])
       "side" : "second"
     } ]
   } ]
-}]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testSortMergeJoin[isNameSimplifyEnabled=true]">
-    <Resource name="explain">
-      <![CDATA[== Abstract Syntax Tree ==
-LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], a0=[$4], b0=[$5], c0=[$6], d0=[$7])
-+- LogicalFilter(condition=[=($0, $7)])
-   +- LogicalJoin(condition=[true], joinType=[inner])
-      :- LogicalTableScan(table=[[default_catalog, default_database, A]])
-      +- LogicalTableScan(table=[[default_catalog, default_database, B]])
-
-== Optimized Physical Plan ==
-SortMergeJoin(joinType=[InnerJoin], where=[=(a, d0)], select=[a, b, c, d, a0, b0, c0, d0])
-:- Exchange(distribution=[hash[a]])
-:  +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])
-+- Exchange(distribution=[hash[d]])
-   +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[a, b, c, d])
-
-== Optimized Execution Plan ==
-SortMergeJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0])
-:- Exchange(distribution=[hash[a]])
-:  +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])
-+- Exchange(distribution=[hash[d]])
-   +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[a, b, c, d])
-
-== Physical Execution Plan ==
-{
-  "nodes" : [ {
-    "id" : ,
-    "type" : "Source: A[]",
-    "pact" : "Data Source",
-    "contents" : "[]:TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a, b, c, d])",
-    "parallelism" : 1
-  }, {
-    "id" : ,
-    "type" : "Source: B[]",
-    "pact" : "Data Source",
-    "contents" : "[]:TableSourceScan(table=[[default_catalog, default_database, B]], fields=[a, b, c, d])",
-    "parallelism" : 1
-  }, {
-    "id" : ,
-    "type" : "SortMergeJoin[]",
-    "pact" : "Operator",
-    "contents" : "[]:SortMergeJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, a0, b0, c0, d0])",
-    "parallelism" : 2,
-    "predecessors" : [ {
-      "id" : ,
-      "ship_strategy" : "HASH[a]",
-      "side" : "second"
-    }, {
-      "id" : ,
-      "ship_strategy" : "HASH[d]",
-      "side" : "second"
-    } ]
-  } ]
 }]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/optimize/ScanReuseTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/optimize/ScanReuseTest.xml
index 0daab2d85b3..6f4bfa0f6a7 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/optimize/ScanReuseTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/optimize/ScanReuseTest.xml
@@ -149,10 +149,10 @@ LogicalProject(a=[$0], c=[$2], c0=[$9])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, c, c0])
-+- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[right])
-   :- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[left])
+   :- Exchange(distribution=[hash[a]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, c], metadata=[]]], fields=[a, c])(reuse_id=[1])
-   +- Exchange(distribution=[hash[a]])
+   +- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
       +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -205,7 +205,7 @@ LogicalProject(a=[$0], i=[$1], j=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, nested_i AS i, nested_j AS j])
-+- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, nested_i, a0, nested_j], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, nested_i, a0, nested_j], build=[left])
    :- Exchange(distribution=[hash[a]])
    :  +- Calc(select=[a, nested_i])
    :     +- TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, nested_i, nested_j], metadata=[]]], fields=[a, nested_i, nested_j])(reuse_id=[1])
@@ -267,10 +267,10 @@ LogicalProject(a=[$0], i=[$1], i0=[$3])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, nested_i AS i, nested_i0 AS i0])
-+- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, nested_i, a0, nested_i0], build=[right])
-   :- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, nested_i, a0, nested_i0], build=[left])
+   :- Exchange(distribution=[hash[a]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, nested_i], metadata=[]]], fields=[a, nested_i])(reuse_id=[1])
-   +- Exchange(distribution=[hash[a]])
+   +- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
       +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -387,10 +387,10 @@ LogicalProject(a=[$0], c=[$2], c0=[$9])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, c, c0])
-+- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[right])
-   :- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[left])
+   :- Exchange(distribution=[hash[a]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, MyTable, filter=[=(b, 1:BIGINT)], project=[a, c], metadata=[]]], fields=[a, c], hints=[[[OPTIONS options:{filterable-fields=b}]]])(reuse_id=[1])
-   +- Exchange(distribution=[hash[a]])
+   +- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
       +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -445,10 +445,10 @@ LogicalProject(a=[$0], c=[$2], c0=[$9])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, c, c0])
-+- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[right])
-   :- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[left])
+   :- Exchange(distribution=[hash[a]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, c], metadata=[]]], fields=[a, c], hints=[[[OPTIONS options:{source.num-element-to-skip=1}]]])(reuse_id=[1])
-   +- Exchange(distribution=[hash[a]])
+   +- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
       +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -572,12 +572,12 @@ LogicalProject(a=[$0], c=[$2], c0=[$9])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, c, c0])
-+- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[right])
-   :- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[left])
+   :- Exchange(distribution=[keep_input_as_is[hash[a]]])
    :  +- Calc(select=[a, CAST('1' AS VARCHAR(2147483647)) AS c])(reuse_id=[1])
    :     +- Exchange(distribution=[hash[a]])
    :        +- TableSourceScan(table=[[default_catalog, default_database, MyTable, partitions=[{c=1}], project=[a], metadata=[]]], fields=[a], hints=[[[OPTIONS options:{partition-list=c:1;c:2}]]])
-   +- Exchange(distribution=[keep_input_as_is[hash[a]]])
+   +- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
       +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -638,7 +638,7 @@ LogicalProject(a=[$0], c=[$2], c0=[$9])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, c, c0])
-+- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[left])
    :- Exchange(distribution=[hash[a]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, c], metadata=[]]], fields=[a, c], hints=[[[OPTIONS options:{source.num-element-to-skip=1}]]])
    +- Exchange(distribution=[hash[a]])
@@ -824,7 +824,7 @@ LogicalProject(a=[$0], c=[$2], c0=[$9])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, c, c0])
-+- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[left])
    :- Exchange(distribution=[hash[a]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, MyTable, filter=[=(b, 2:BIGINT)], project=[a, c], metadata=[]]], fields=[a, c], hints=[[[OPTIONS options:{filterable-fields=b}]]])
    +- Exchange(distribution=[hash[a]])
@@ -884,7 +884,7 @@ LogicalProject(a=[$0], c=[$2], c0=[$9])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, c, c0])
-+- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[left])
    :- Exchange(distribution=[hash[a]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, c], metadata=[]]], fields=[a, c], hints=[[[OPTIONS options:{source.num-element-to-skip=1}]]])
    +- Exchange(distribution=[hash[a]])
@@ -1251,7 +1251,7 @@ LogicalProject(a=[$0], c=[$2], c0=[$9])
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, c, c0])
-+- MultipleInput(readOrder=[1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[right])\n:- Calc(select=[a, CAST('1' AS VARCHAR(2147483647)) AS c])\n:  +- [#1] Exchange(distribution=[hash[a]])\n+- Calc(select=[a, CAST('2' AS VARCHAR(2147483647)) AS c])\n   +- [#2] Exchange(distribution=[hash[a]])\n])
++- MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, c, a0, c0], build=[left])\n:- Calc(select=[a, CAST('1' AS VARCHAR(2147483647)) AS c])\n:  +- [#1] Exchange(distribution=[hash[a]])\n+- Calc(select=[a, CAST('2' AS VARCHAR(2147483647)) AS c])\n   +- [#2] Exchange(distribution=[hash[a]])\n])
    :- Exchange(distribution=[hash[a]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, MyTable, partitions=[{c=1}], project=[a], metadata=[]]], fields=[a], hints=[[[OPTIONS options:{partition-list=c:1;c:2}]]])
    +- Exchange(distribution=[hash[a]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/optimize/program/FlinkRuntimeFilterProgramTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/optimize/program/FlinkRuntimeFilterProgramTest.xml
index f3eaf8b9b0d..6fe08aa83d4 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/optimize/program/FlinkRuntimeFilterProgramTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/optimize/program/FlinkRuntimeFilterProgramTest.xml
@@ -461,7 +461,7 @@ HashJoin(joinType=[InnerJoin], where=[=(fact_date_sk, dim_date_sk)], select=[id,
 :     :           +- Calc(select=[dim_date_sk, amount])
 :     :              +- TableSourceScan(table=[[testCatalog, test_database, dim, project=[amount, price, dim_date_sk], metadata=[]]], fields=[amount, price, dim_date_sk])
 :     +- TableSourceScan(table=[[testCatalog, test_database, fact]], fields=[id, name, amount, price, fact_date_sk])
-+- HashJoin(joinType=[InnerJoin], where=[=(dim_date_sk, dim_date_sk0)], select=[dim_date_sk, EXPR$1, dim_date_sk0, EXPR$10], build=[right])
++- HashJoin(joinType=[InnerJoin], where=[=(dim_date_sk, dim_date_sk0)], select=[dim_date_sk, EXPR$1, dim_date_sk0, EXPR$10], build=[left])
    :- HashAggregate(isMerge=[false], groupBy=[dim_date_sk], select=[dim_date_sk, SUM(price) AS EXPR$1])
    :  +- Exchange(distribution=[hash[dim_date_sk]])
    :     +- Calc(select=[dim_date_sk, price])
@@ -474,7 +474,7 @@ HashJoin(joinType=[InnerJoin], where=[=(fact_date_sk, dim_date_sk)], select=[id,
 		</Resource>
 		<Resource name="optimized exec plan">
 			<![CDATA[
-MultipleInput(readOrder=[2,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(fact_date_sk = dim_date_sk)], select=[id, name, amount, price, fact_date_sk, dim_date_sk, EXPR$1, dim_date_sk0, EXPR$10], build=[right])\n:- [#1] Exchange(distribution=[hash[fact_date_sk]])\n+- HashJoin(joinType=[InnerJoin], where=[(dim_date_sk = dim_date_sk0)], select=[dim_date_sk, EXPR$1, dim_date_sk0, EXPR$10], build=[right])\n   :- HashAggregate(isMerge=[false], groupBy=[dim_date_sk], select=[dim_date_ [...]
+MultipleInput(readOrder=[2,0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(fact_date_sk = dim_date_sk)], select=[id, name, amount, price, fact_date_sk, dim_date_sk, EXPR$1, dim_date_sk0, EXPR$10], build=[right])\n:- [#1] Exchange(distribution=[hash[fact_date_sk]])\n+- HashJoin(joinType=[InnerJoin], where=[(dim_date_sk = dim_date_sk0)], select=[dim_date_sk, EXPR$1, dim_date_sk0, EXPR$10], build=[left])\n   :- HashAggregate(isMerge=[false], groupBy=[dim_date_sk], select=[dim_date_s [...]
 :- Exchange(distribution=[hash[fact_date_sk]])
 :  +- MultipleInput(readOrder=[0,1], members=[\nRuntimeFilter(select=[fact_date_sk], estimatedFilterRatio=[0.9998779296875])\n:- [#1] Exchange(distribution=[broadcast])\n+- [#2] TableSourceScan(table=[[testCatalog, test_database, fact]], fields=[id, name, amount, price, fact_date_sk])\n])
 :     :- Exchange(distribution=[broadcast])