From 8d5ba352a9596f9ef5c88d999f94006830b894c3 Mon Sep 17 00:00:00 2001
From: Sergey Nuyanzin <snuyanzin@gmail.com>
Date: Wed, 13 May 2026 20:49:41 +0200
Subject: [PATCH 1/5] [FLINK-36602][table] Upgrade Calcite version to 1.38.0

---
 flink-python/pyflink/table/tests/test_udf.py  |    2 +-
 flink-table/flink-sql-parser/pom.xml          |    8 +-
 .../src/main/codegen/data/Parser.tdd          |    1 -
 .../src/main/codegen/templates/Parser.jj      |  117 +-
 .../java/org/apache/calcite/sql/SqlJoin.java  |  293 ---
 .../parser/validate/FlinkSqlConformance.java  |    5 -
 .../sql/parser/FlinkSqlParserImplTest.java    |    3 +
 .../flink-table-calcite-bridge/pom.xml        |    6 +-
 .../functions/BuiltInFunctionDefinitions.java |    2 +-
 .../org/apache/calcite/plan/RelOptUtil.java   |  107 +-
 .../calcite/rel/metadata/RelMdPredicates.java | 1051 --------
 .../calcite/rel/rules/SubQueryRemoveRule.java |   10 +-
 .../rel/type/RelDataTypeFactoryImpl.java      |   19 +-
 .../org/apache/calcite/rex/RexBuilder.java    |  437 +++-
 .../org/apache/calcite/rex/RexChecker.java    |   34 +-
 .../org/apache/calcite/rex/RexShuttle.java    |   35 +-
 .../java/org/apache/calcite/rex/RexUtil.java  |   67 +-
 .../apache/calcite/runtime/SqlFunctions.java  |  647 ++++-
 .../calcite/sql/SqlIntervalQualifier.java     |   51 +-
 .../java/org/apache/calcite/sql/SqlUtil.java  |   76 +-
 .../apache/calcite/sql/type/BasicSqlType.java |  322 +++
 .../calcite/sql/type/SqlTypeFactoryImpl.java  |   18 +-
 .../apache/calcite/sql/type/SqlTypeUtil.java  |   96 +-
 .../sql/validate/SqlValidatorImpl.java        |  502 +++-
 .../apache/calcite/sql2rel/AggConverter.java  |   33 +-
 .../calcite/sql2rel/RelDecorrelator.java      |   73 +-
 .../calcite/sql2rel/SqlToRelConverter.java    |  615 +++--
 .../sql2rel/StandardConvertletTable.java      | 2183 -----------------
 .../planner/calcite/FlinkConvertletTable.java |   22 +
 .../planner/calcite/FlinkTypeFactory.java     |    7 +-
 .../planner/calcite/FlinkTypeSystem.java      |   10 +
 .../calcite/RelTimeIndicatorConverter.java    |    1 +
 .../exec/serde/RexNodeJsonDeserializer.java   |    6 +-
 .../nodes/exec/utils/CommonPythonUtil.java    |    4 +-
 ...markIntoTableSourceScanAcrossCalcRule.java |    2 +-
 .../plan/schema/TimeIndicatorRelDataType.java |   76 +
 .../src/main/resources/META-INF/NOTICE        |    4 +-
 .../planner/codegen/ExpressionReducer.scala   |   14 +-
 .../BatchPhysicalOverAggregateRule.scala      |    1 +
 .../schema/TimeIndicatorRelDataType.scala     |   55 -
 .../planner/plan/utils/FlinkRelOptUtil.scala  |    4 +-
 .../planner/plan/utils/FlinkRexUtil.scala     |    2 +-
 .../plan/utils/OverAggregateUtil.scala        |    1 +
 .../functions/JsonFunctionsITCase.java        |   30 +-
 .../SqlNodeToCallOperationTest.java           |    2 +-
 .../plan/batch/sql/RowLevelUpdateTest.java    |    7 +-
 .../exec/serde/RexNodeJsonSerdeTest.java      |    2 +-
 .../table/planner/plan/batch/sql/CalcTest.xml |   10 +-
 .../plan/batch/sql/DeadlockBreakupTest.xml    |    6 +-
 .../batch/sql/ForwardHashExchangeTest.xml     |    8 +-
 .../plan/batch/sql/RemoveCollationTest.xml    |    4 +-
 .../plan/batch/sql/RemoveShuffleTest.xml      |   16 +-
 .../plan/batch/sql/SubplanReuseTest.xml       |    8 +-
 .../planner/plan/batch/sql/TableSinkTest.xml  |   10 +-
 .../planner/plan/batch/sql/UnionTest.xml      |    2 +-
 .../planner/plan/batch/sql/ValuesTest.xml     |    3 +-
 .../plan/batch/sql/agg/OverAggregateTest.xml  |   54 +-
 .../AggregateReduceFunctionsRuleTest.xml      |    4 +-
 .../logical/ConvertToNotInOrInRuleTest.xml    |   22 +-
 .../logical/FlinkPruneEmptyRulesTest.xml      |   27 +-
 .../PushFilterIntoTableSourceScanRuleTest.xml |    2 +-
 ...veUnreachableCoalesceArgumentsRuleTest.xml |    4 +-
 .../logical/WindowGroupReorderRuleTest.xml    |   32 +-
 .../logical/subquery/SubQuerySemiJoinTest.xml |   61 +
 ...ushLocalAggIntoTableSourceScanRuleTest.xml |    4 +-
 .../planner/plan/stream/sql/CalcTest.xml      |    8 +-
 .../planner/plan/stream/sql/DeltaJoinTest.xml |    4 +-
 .../plan/stream/sql/MatchRecognizeTest.xml    |    4 +-
 .../planner/plan/stream/sql/UnionTest.xml     |    2 +-
 .../planner/plan/stream/sql/ValuesTest.xml    |    3 +-
 .../plan/stream/sql/agg/AggregateTest.xml     |    4 +-
 .../plan/stream/sql/agg/OverAggregateTest.xml |   46 +-
 .../planner/plan/stream/table/ValuesTest.xml  |   82 +-
 .../FlinkRelMdColumnIntervalTest.scala        |    6 +-
 .../metadata/FlinkRelMdHandlerTestBase.scala  |    4 +
 .../metadata/FlinkRelMdSelectivityTest.scala  |    1 +
 .../metadata/FlinkRelMdUpsertKeysTest.scala   |    1 +
 .../logical/FlinkPruneEmptyRulesTest.scala    |    2 +-
 .../subquery/SubQueryAntiJoinTest.scala       |    2 +-
 .../subquery/SubQuerySemiJoinTest.scala       |   40 +-
 flink-table/pom.xml                           |    2 +-
 81 files changed, 3004 insertions(+), 4547 deletions(-)
 delete mode 100644 flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlJoin.java
 delete mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/metadata/RelMdPredicates.java
 create mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java
 delete mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
 create mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/schema/TimeIndicatorRelDataType.java
 delete mode 100644 flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/schema/TimeIndicatorRelDataType.scala

diff --git a/flink-python/pyflink/table/tests/test_udf.py b/flink-python/pyflink/table/tests/test_udf.py
index 182c46bbd9cf8..588add0ffba99 100644
--- a/flink-python/pyflink/table/tests/test_udf.py
+++ b/flink-python/pyflink/table/tests/test_udf.py
@@ -218,7 +218,7 @@ def udf_with_constant_params(p, null_param, tinyint_param, smallint_param, int_p
                              "cast (1 as SMALLINT),"
                              "cast (1 as INT),"
                              "cast (1 as BIGINT),"
-                             "cast (1.05 as DECIMAL),"
+                             "cast (1.05 as DECIMAL(3,2)),"
                              "cast (1.23 as FLOAT),"
                              "cast (1.98932 as DOUBLE),"
                              "true,"
diff --git a/flink-table/flink-sql-parser/pom.xml b/flink-table/flink-sql-parser/pom.xml
index 366d6d8ea1f2f..0264583bfecc7 100644
--- a/flink-table/flink-sql-parser/pom.xml
+++ b/flink-table/flink-sql-parser/pom.xml
@@ -68,13 +68,13 @@ under the License.
 			<version>${calcite.version}</version>
 			<exclusions>
 				<!--
-				"mvn dependency:tree" as of Calcite 1.37.0:
+				"mvn dependency:tree" as of Calcite 1.38.0:
 
-				[INFO] +- org.apache.calcite:calcite-core:jar:1.37.0:compile
-				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.37.0:compile
+				[INFO] +- org.apache.calcite:calcite-core:jar:1.38.0:compile
+				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.38.0:compile
 				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.25.0:compile
 				[INFO] |  +- org.apiguardian:apiguardian-api:jar:1.1.2:compile
-				[INFO] |  +- org.checkerframework:checker-qual:jar:3.37.0:compile
+				[INFO] |  +- org.checkerframework:checker-qual:jar:3.43.0:compile
 				[INFO] |  \- org.apache.commons:commons-math3:jar:3.6.1:runtime
 
 				Dependencies that are not needed for how we use Calcite right now.
diff --git a/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd b/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd
index 1b73936914928..74339361d7939 100644
--- a/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd
+++ b/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd
@@ -185,7 +185,6 @@
     "org.apache.calcite.sql.SqlDrop"
     "org.apache.calcite.sql.SqlExplicitModelOperator"
     "org.apache.calcite.sql.SqlIntervalLiteral"
-    "org.apache.calcite.sql.SqlLambda"
     "org.apache.calcite.runtime.Resources"
     "java.util.ArrayList"
     "java.util.Collections"
diff --git a/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj b/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
index 1f0ae3d455cd8..0c6671b132a4b 100644
--- a/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
+++ b/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
@@ -40,6 +40,7 @@ import org.apache.calcite.runtime.CalciteContextException;
 import org.apache.calcite.sql.JoinConditionType;
 import org.apache.calcite.sql.JoinType;
 import org.apache.calcite.sql.SqlAlter;
+import org.apache.calcite.sql.SqlAsofJoin;
 import org.apache.calcite.sql.SqlBasicTypeNameSpec;
 import org.apache.calcite.sql.SqlBinaryOperator;
 import org.apache.calcite.sql.SqlCall;
@@ -73,6 +74,7 @@ import org.apache.calcite.sql.SqlJsonQueryWrapperBehavior;
 import org.apache.calcite.sql.SqlJsonValueEmptyOrErrorBehavior;
 import org.apache.calcite.sql.SqlJsonValueReturning;
 import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlLambda;
 import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlMatchRecognize;
 import org.apache.calcite.sql.SqlMerge;
@@ -1743,10 +1745,10 @@ SqlNode SqlInsert() :
     (
         LOOKAHEAD(2)
         p = ParenthesizedCompoundIdentifierList() {
-            if (p.right.size() > 0) {
+            if (!p.right.isEmpty()) {
                 tableRef = extend(tableRef, p.right);
             }
-            if (p.left.size() > 0) {
+            if (!p.left.isEmpty()) {
                 columnList = p.left;
             } else {
                 columnList = null;
@@ -1818,14 +1820,14 @@ SqlNode SqlUpdate() :
     ( tableRef = TableHints(tableName) | { tableRef = tableName; } )
     [ tableRef = ExtendTable(tableRef) ]
     ( [ <AS> ] alias = SimpleIdentifier() | { alias = null; } )
-    <SET> id = SimpleIdentifier() {
+    <SET> id = CompoundIdentifier() {
         targetColumnList.add(id);
     }
     // TODO:  support DEFAULT also
     <EQ> AddExpression(sourceExpressionList, ExprContext.ACCEPT_SUB_QUERY)
     (
         <COMMA>
-        id = SimpleIdentifier() { targetColumnList.add(id); }
+        id = CompoundIdentifier() { targetColumnList.add(id); }
         <EQ> AddExpression(sourceExpressionList, ExprContext.ACCEPT_SUB_QUERY)
     )*
     ( where = Where() | { where = null; } )
@@ -1943,13 +1945,19 @@ SqlInsert WhenNotMatchedClause(SqlNode table) :
  */
 void AddSelectItem(List<SqlNode> list) :
 {
-    final SqlNode e;
+    SqlNode e;
     final SqlIdentifier id;
 }
 {
     e = SelectExpression()
     (
-        [ <AS> ]
+        [ <AS>
+            [ <MEASURE> {
+                    e = SqlInternalOperators.MEASURE.createCall(
+                        e.getParserPosition(), e);
+                }
+            ]
+        ]
         (
             id = SimpleIdentifier()
         |
@@ -1992,6 +2000,7 @@ SqlLiteral Natural() :
 SqlLiteral JoinType() :
 {
     JoinType joinType;
+    boolean asof = false;
 }
 {
     (
@@ -2004,7 +2013,9 @@ SqlLiteral JoinType() :
     |
         <INNER> <JOIN> { joinType = JoinType.INNER; }
     |
-        <LEFT> [ <OUTER> ] <JOIN> { joinType = JoinType.LEFT; }
+        <ASOF> <JOIN> { joinType = JoinType.ASOF; }
+    |
+        <LEFT> [ <OUTER> | <ASOF> { asof = true; } ] <JOIN> { joinType = asof ? JoinType.LEFT_ASOF : JoinType.LEFT; }
     |
         <RIGHT> [ <OUTER> ] <JOIN> { joinType = JoinType.RIGHT; }
     |
@@ -2068,7 +2079,7 @@ SqlNode JoinOrCommaTable(SqlNode e) :
 /** Matches "LEFT JOIN t ON ...", "RIGHT JOIN t USING ...", "JOIN t". */
 SqlNode JoinTable(SqlNode e) :
 {
-    SqlNode e2, condition;
+    SqlNode e2, condition, matchCondition = null;
     final SqlLiteral natural, joinType, on, using;
     SqlNodeList list;
 }
@@ -2085,13 +2096,32 @@ SqlNode JoinTable(SqlNode e) :
     //
     // We allow CROSS JOIN (joinType = CROSS_JOIN) to have a join condition,
     // even though that is not valid SQL; the validator will catch it.
-    LOOKAHEAD(3)
+    LOOKAHEAD(4)
     natural = Natural()
     joinType = JoinType()
     e2 = TableRef1(ExprContext.ACCEPT_QUERY_OR_JOIN)
     (
+        [ <MATCH_CONDITION> matchCondition = Expression(ExprContext.ACCEPT_SUB_QUERY) ]
         <ON> { on = JoinConditionType.ON.symbol(getPos()); }
         condition = Expression(ExprContext.ACCEPT_SUB_QUERY) {
+            JoinType type = joinType.getValueAs(JoinType.class);
+            if (matchCondition != null) {
+                if (type != JoinType.ASOF && type != JoinType.LEFT_ASOF) {
+                    throw SqlUtil.newContextException(getPos(), RESOURCE.matchConditionRequiresAsof());
+                }
+                return new SqlAsofJoin(joinType.getParserPosition(),
+                    e,
+                    natural,
+                    joinType,
+                    e2,
+                    on,
+                    condition,
+                    matchCondition);
+            } else {
+                if (type == JoinType.ASOF || type == JoinType.LEFT_ASOF) {
+                    throw SqlUtil.newContextException(getPos(), RESOURCE.asofRequiresMatchCondition());
+                }
+            }
             return new SqlJoin(joinType.getParserPosition(),
                 e,
                 natural,
@@ -2740,6 +2770,7 @@ SqlWindow WindowSpecification() :
     final SqlNodeList orderList;
     final SqlLiteral isRows;
     final SqlNode lowerBound, upperBound;
+    final SqlLiteral exclude;
     final Span s, s1, s2;
     final SqlLiteral allowPartial;
 }
@@ -2772,9 +2803,11 @@ SqlWindow WindowSpecification() :
             lowerBound = WindowRange()
             { upperBound = null; }
         )
+        exclude = WindowExclusion()
     |
         {
             isRows = SqlLiteral.createBoolean(false, SqlParserPos.ZERO);
+            exclude = SqlWindow.createExcludeNoOthers(getPos());
             lowerBound = upperBound = null;
         }
     )
@@ -2791,7 +2824,7 @@ SqlWindow WindowSpecification() :
     <RPAREN>
     {
         return SqlWindow.create(null, id, partitionList, orderList,
-            isRows, lowerBound, upperBound, allowPartial, s.end(this));
+            isRows, lowerBound, upperBound, allowPartial, exclude, s.end(this));
     }
 }
 
@@ -2830,6 +2863,27 @@ SqlNode WindowRange() :
     )
 }
 
+/** Parses an exclusion clause for WINDOW FRAME. */
+SqlLiteral WindowExclusion() :
+{
+}
+{
+    (
+        <EXCLUDE>
+        (
+            <CURRENT> <ROW> { return SqlWindow.createExcludeCurrentRow(getPos()); }
+        |
+            <NO> <OTHERS> { return SqlWindow.createExcludeNoOthers(getPos()); }
+        |
+            <GROUP> { return SqlWindow.createExcludeGroup(getPos()); }
+        |
+            <TIES> { return SqlWindow.createExcludeTies(getPos()); }
+        )
+    |
+        { return SqlWindow.createExcludeNoOthers(SqlParserPos.ZERO); }
+    )
+}
+
 /** Parses a QUALIFY clause for SELECT. */
 SqlNode Qualify() :
 {
@@ -3791,8 +3845,12 @@ List<Object> Expression2(ExprContext exprContext) :
                 AddExpression2b(list, ExprContext.ACCEPT_SUB_QUERY)
             |
                 <LBRACKET>
-                itemOp = getItemOp()
-                e = Expression(ExprContext.ACCEPT_SUB_QUERY)
+                ( <OFFSET> { itemOp = SqlLibraryOperators.OFFSET; } <LPAREN> { e = Expression(ExprContext.ACCEPT_SUB_QUERY); } <RPAREN>
+                | <ORDINAL> { itemOp = SqlLibraryOperators.ORDINAL; } <LPAREN> { e = Expression(ExprContext.ACCEPT_SUB_QUERY); } <RPAREN>
+                | <SAFE_OFFSET> { itemOp = SqlLibraryOperators.SAFE_OFFSET; } <LPAREN> { e = Expression(ExprContext.ACCEPT_SUB_QUERY); } <RPAREN>
+                | <SAFE_ORDINAL> { itemOp = SqlLibraryOperators.SAFE_ORDINAL; } <LPAREN> { e = Expression(ExprContext.ACCEPT_SUB_QUERY); } <RPAREN>
+                | { itemOp = SqlStdOperatorTable.ITEM; } e = Expression(ExprContext.ACCEPT_SUB_QUERY)
+                )
                 <RBRACKET> {
                     list.add(
                         new SqlParserUtil.ToTreeListItem(
@@ -3827,22 +3885,6 @@ List<Object> Expression2(ExprContext exprContext) :
     )
 }
 
-/** Returns the appropriate ITEM operator for indexing arrays. */
-SqlOperator getItemOp() :
-{
-}
-{
-    <OFFSET> { return SqlLibraryOperators.OFFSET; }
-|
-    <ORDINAL> { return SqlLibraryOperators.ORDINAL; }
-|
-    <SAFE_OFFSET> { return SqlLibraryOperators.SAFE_OFFSET; }
-|
-    <SAFE_ORDINAL> { return SqlLibraryOperators.SAFE_ORDINAL; }
-|
-    { return SqlStdOperatorTable.ITEM; }
-}
-
 /** Parses a comparison operator inside a SOME / ALL predicate. */
 SqlKind comp() :
 {
@@ -3961,7 +4003,7 @@ SqlNode Expression3(ExprContext exprContext) :
     {
         if (list1.size() == 1) {
             // interpret as single value or query
-            return list1.get(0);
+            return list1.get(0).clone(list1.getParserPosition());
         } else {
             // interpret as row constructor
             return SqlStdOperatorTable.ROW.createCall(span().end(list1),
@@ -4842,9 +4884,9 @@ SqlLiteral DateTimeLiteral() :
     }
 |
     LOOKAHEAD(2)
-        <TIME> { s = span(); } <WITH> ( <LOCAL> { local = true; } )? <TIME> <ZONE> p = SimpleStringLiteral() {
-            return SqlLiteral.createUnknown("TIME WITH " + (local ? "LOCAL " : "") + "TIME ZONE", p, s.end(this));
-        }
+    <TIME> { s = span(); } <WITH> ( <LOCAL> { local = true; } )? <TIME> <ZONE> p = SimpleStringLiteral() {
+        return SqlLiteral.createUnknown("TIME WITH " + (local ? "LOCAL " : "") + "TIME ZONE", p, s.end(this));
+    }
 |
     LOOKAHEAD(2)
     <TIMESTAMP> { s = span(); } <WITH> ( <LOCAL> { local = true; } )? <TIME> <ZONE> p = SimpleStringLiteral() {
@@ -4937,7 +4979,7 @@ SqlNode ArrayConstructor() :
         // by enumeration "ARRAY[e0, e1, ..., eN]"
         <LBRACKET> // TODO: do trigraph as well ??( ??)
         (
-            args = ExpressionCommaList(s, ExprContext.ACCEPT_NON_QUERY)
+            args = ExpressionCommaList(s, ExprContext.ACCEPT_SUB_QUERY)
         |
             { args = SqlNodeList.EMPTY; }
         )
@@ -5904,8 +5946,8 @@ SqlTypeNameSpec SqlTypeName2(Span s) :
 SqlTypeNameSpec SqlTypeName3(Span s) :
 {
     final SqlTypeName sqlTypeName;
-    int precision = -1;
-    int scale = -1;
+    int precision = RelDataType.PRECISION_NOT_SPECIFIED;
+    int scale = RelDataType.SCALE_NOT_SPECIFIED;
 }
 {
     (
@@ -5918,7 +5960,7 @@ SqlTypeNameSpec SqlTypeName3(Span s) :
         precision = UnsignedIntLiteral()
         [
             <COMMA>
-            scale = UnsignedIntLiteral()
+            scale = IntLiteral()
         ]
         <RPAREN>
     ]
@@ -8016,6 +8058,7 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < ARRAY_CONCAT_AGG: "ARRAY_CONCAT_AGG" >
 |   < ARRAY_MAX_CARDINALITY: "ARRAY_MAX_CARDINALITY" >
 |   < AS: "AS" >
+|   < ASOF: "ASOF" >
 |   < ASC: "ASC" >
 |   < ASENSITIVE: "ASENSITIVE" >
 |   < ASSERTION: "ASSERTION" >
@@ -8316,10 +8359,12 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < MATCH: "MATCH" >
 |   < MATCHED: "MATCHED" >
 |   < MATCHES: "MATCHES" >
+|   < MATCH_CONDITION: "MATCH_CONDITION">
 |   < MATCH_NUMBER: "MATCH_NUMBER">
 |   < MATCH_RECOGNIZE: "MATCH_RECOGNIZE">
 |   < MAX: "MAX" >
 |   < MAXVALUE: "MAXVALUE" >
+|   < MEASURE: "MEASURE" >
 |   < MEASURES: "MEASURES" >
 |   < MEMBER: "MEMBER" >
 |   < MERGE: "MERGE" > { beforeTableName(); }
diff --git a/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlJoin.java b/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlJoin.java
deleted file mode 100644
index 455255cd6cc81..0000000000000
--- a/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlJoin.java
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.calcite.sql;
-
-import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.util.SqlString;
-import org.apache.calcite.util.ImmutableNullableList;
-import org.apache.calcite.util.Util;
-import org.checkerframework.checker.nullness.qual.Nullable;
-
-import java.util.List;
-import java.util.function.UnaryOperator;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static java.util.Objects.requireNonNull;
-
-/** Parse tree node representing a {@code JOIN} clause. */
-public class SqlJoin extends SqlCall {
-    static final SqlJoinOperator COMMA_OPERATOR = new SqlJoinOperator("COMMA-JOIN", 18);
-    public static final SqlJoinOperator OPERATOR = new SqlJoinOperator("JOIN", 18);
-
-    SqlNode left;
-
-    /** Operand says whether this is a natural join. Must be constant TRUE or FALSE. */
-    SqlLiteral natural;
-
-    /** Value must be a {@link SqlLiteral}, one of the integer codes for {@link JoinType}. */
-    SqlLiteral joinType;
-
-    SqlNode right;
-
-    /**
-     * Value must be a {@link SqlLiteral}, one of the integer codes for {@link JoinConditionType}.
-     */
-    SqlLiteral conditionType;
-
-    @Nullable SqlNode condition;
-
-    // ~ Constructors -----------------------------------------------------------
-
-    public SqlJoin(
-            SqlParserPos pos,
-            SqlNode left,
-            SqlLiteral natural,
-            SqlLiteral joinType,
-            SqlNode right,
-            SqlLiteral conditionType,
-            @Nullable SqlNode condition) {
-        super(pos);
-        this.left = left;
-        this.natural = requireNonNull(natural, "natural");
-        this.joinType = requireNonNull(joinType, "joinType");
-        this.right = right;
-        this.conditionType = requireNonNull(conditionType, "conditionType");
-        this.condition = condition;
-
-        checkArgument(natural.getTypeName() == SqlTypeName.BOOLEAN);
-        conditionType.getValueAs(JoinConditionType.class);
-        joinType.getValueAs(JoinType.class);
-    }
-
-    // ~ Methods ----------------------------------------------------------------
-
-    @Override
-    public SqlOperator getOperator() {
-        //noinspection SwitchStatementWithTooFewBranches
-        switch (getJoinType()) {
-            case COMMA:
-                return COMMA_OPERATOR;
-            default:
-                return OPERATOR;
-        }
-    }
-
-    @Override
-    public SqlKind getKind() {
-        return SqlKind.JOIN;
-    }
-
-    @SuppressWarnings("nullness")
-    @Override
-    public List<SqlNode> getOperandList() {
-        return ImmutableNullableList.of(left, natural, joinType, right, conditionType, condition);
-    }
-
-    @SuppressWarnings("assignment.type.incompatible")
-    @Override
-    public void setOperand(int i, @Nullable SqlNode operand) {
-        switch (i) {
-            case 0:
-                left = operand;
-                break;
-            case 1:
-                natural = (SqlLiteral) operand;
-                break;
-            case 2:
-                joinType = (SqlLiteral) operand;
-                break;
-            case 3:
-                right = operand;
-                break;
-            case 4:
-                conditionType = (SqlLiteral) operand;
-                break;
-            case 5:
-                condition = operand;
-                break;
-            default:
-                throw new AssertionError(i);
-        }
-    }
-
-    public final @Nullable SqlNode getCondition() {
-        return condition;
-    }
-
-    /** Returns a {@link JoinConditionType}, never null. */
-    public final JoinConditionType getConditionType() {
-        return conditionType.getValueAs(JoinConditionType.class);
-    }
-
-    public SqlLiteral getConditionTypeNode() {
-        return conditionType;
-    }
-
-    /** Returns a {@link JoinType}, never null. */
-    public final JoinType getJoinType() {
-        return joinType.getValueAs(JoinType.class);
-    }
-
-    public SqlLiteral getJoinTypeNode() {
-        return joinType;
-    }
-
-    public final SqlNode getLeft() {
-        return left;
-    }
-
-    public void setLeft(SqlNode left) {
-        this.left = left;
-    }
-
-    public final boolean isNatural() {
-        return natural.booleanValue();
-    }
-
-    public final SqlLiteral isNaturalNode() {
-        return natural;
-    }
-
-    public final SqlNode getRight() {
-        return right;
-    }
-
-    public void setRight(SqlNode right) {
-        this.right = right;
-    }
-
-    /**
-     * Describes the syntax of the SQL {@code JOIN} operator.
-     *
-     * <p>A variant describes the comma operator, which has lower precedence.
-     */
-    public static class SqlJoinOperator extends SqlOperator {
-        private static final SqlWriter.FrameType FRAME_TYPE =
-                SqlWriter.FrameTypeEnum.create("USING");
-
-        // ~ Constructors -----------------------------------------------------------
-
-        private SqlJoinOperator(String name, int prec) {
-            super(name, SqlKind.JOIN, prec, true, null, null, null);
-        }
-
-        // ~ Methods ----------------------------------------------------------------
-
-        @Override
-        public SqlSyntax getSyntax() {
-            return SqlSyntax.SPECIAL;
-        }
-
-        @SuppressWarnings("argument.type.incompatible")
-        @Override
-        public SqlCall createCall(
-                @Nullable SqlLiteral functionQualifier,
-                SqlParserPos pos,
-                @Nullable SqlNode... operands) {
-            assert functionQualifier == null;
-            return new SqlJoin(
-                    pos,
-                    operands[0],
-                    (SqlLiteral) operands[1],
-                    (SqlLiteral) operands[2],
-                    operands[3],
-                    (SqlLiteral) operands[4],
-                    operands[5]);
-        }
-
-        @Override
-        public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
-            final SqlJoin join = (SqlJoin) call;
-
-            join.left.unparse(writer, leftPrec, getLeftPrec());
-            switch (join.getJoinType()) {
-                case COMMA:
-                    writer.sep(",", true);
-                    break;
-                case CROSS:
-                    writer.sep(join.isNatural() ? "NATURAL CROSS JOIN" : "CROSS JOIN");
-                    break;
-                case FULL:
-                    writer.sep(join.isNatural() ? "NATURAL FULL JOIN" : "FULL JOIN");
-                    break;
-                case INNER:
-                    writer.sep(join.isNatural() ? "NATURAL INNER JOIN" : "INNER JOIN");
-                    break;
-                case LEFT:
-                    writer.sep(join.isNatural() ? "NATURAL LEFT JOIN" : "LEFT JOIN");
-                    break;
-                case LEFT_SEMI_JOIN:
-                    writer.sep(join.isNatural() ? "NATURAL LEFT SEMI JOIN" : "LEFT SEMI JOIN");
-                    break;
-                case LEFT_ANTI_JOIN:
-                    writer.sep(join.isNatural() ? "NATURAL LEFT ANTI JOIN" : "LEFT ANTI JOIN");
-                    break;
-                case RIGHT:
-                    writer.sep(join.isNatural() ? "NATURAL RIGHT JOIN" : "RIGHT JOIN");
-                    break;
-                default:
-                    throw Util.unexpected(join.getJoinType());
-            }
-            join.right.unparse(writer, getRightPrec(), rightPrec);
-            SqlNode joinCondition = join.condition;
-            if (joinCondition != null) {
-                switch (join.getConditionType()) {
-                    case USING:
-                        // No need for an extra pair of parens -- the condition is a
-                        // list. The result is something like "USING (deptno, gender)".
-                        writer.keyword("USING");
-                        assert joinCondition instanceof SqlNodeList
-                                : "joinCondition should be SqlNodeList, got " + joinCondition;
-                        final SqlWriter.Frame frame = writer.startList(FRAME_TYPE, "(", ")");
-                        joinCondition.unparse(writer, 0, 0);
-                        writer.endList(frame);
-                        break;
-
-                    case ON:
-                        writer.keyword("ON");
-                        joinCondition.unparse(writer, leftPrec, rightPrec);
-                        break;
-
-                    default:
-                        throw Util.unexpected(join.getConditionType());
-                }
-            }
-        }
-    }
-
-    @Override
-    public SqlString toSqlString(UnaryOperator<SqlWriterConfig> transform) {
-        SqlNode selectWrapper =
-                new SqlSelect(
-                        SqlParserPos.ZERO,
-                        SqlNodeList.EMPTY,
-                        SqlNodeList.SINGLETON_STAR,
-                        this,
-                        null,
-                        null,
-                        null,
-                        SqlNodeList.EMPTY,
-                        null,
-                        null,
-                        null,
-                        null,
-                        SqlNodeList.EMPTY);
-        return selectWrapper.toSqlString(transform);
-    }
-}
diff --git a/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java b/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
index e00def6f715ab..a7a58c9958d51 100644
--- a/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
+++ b/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
@@ -97,11 +97,6 @@ public boolean isMinusAllowed() {
         return false;
     }
 
-    @Override
-    public boolean isRegexReplaceCaptureGroupDollarIndexed() {
-        return true;
-    }
-
     @Override
     public boolean isApplyAllowed() {
         return false;
diff --git a/flink-table/flink-sql-parser/src/test/java/org/apache/flink/sql/parser/FlinkSqlParserImplTest.java b/flink-table/flink-sql-parser/src/test/java/org/apache/flink/sql/parser/FlinkSqlParserImplTest.java
index 1d1e7d639fa00..b5ea58c8ea2d2 100644
--- a/flink-table/flink-sql-parser/src/test/java/org/apache/flink/sql/parser/FlinkSqlParserImplTest.java
+++ b/flink-table/flink-sql-parser/src/test/java/org/apache/flink/sql/parser/FlinkSqlParserImplTest.java
@@ -73,6 +73,9 @@ void testMapQueryConstructor() {}
     @Test
     void testMultisetQueryConstructor() {}
 
+    @Test
+    void testMeasure() {}
+
     @Test
     void testShowCatalogs() {
         sql("show catalogs").ok("SHOW CATALOGS");
diff --git a/flink-table/flink-table-calcite-bridge/pom.xml b/flink-table/flink-table-calcite-bridge/pom.xml
index 2de3dced880a1..de1a516e2aff0 100644
--- a/flink-table/flink-table-calcite-bridge/pom.xml
+++ b/flink-table/flink-table-calcite-bridge/pom.xml
@@ -45,9 +45,9 @@ under the License.
 			<version>${calcite.version}</version>
 			<exclusions>
 				<!--
-				"mvn dependency:tree" as of Calcite 1.37.0:
-				[INFO] +- org.apache.calcite:calcite-core:jar:1.37.0:compile
-				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.37.0:compile
+				"mvn dependency:tree" as of Calcite 1.38.0:
+				[INFO] +- org.apache.calcite:calcite-core:jar:1.38.0:compile
+				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.38.0:compile
 				[INFO] |  +- org.locationtech.jts:jts-core:jar:1.19.0:compile
 				[INFO] |  +- com.fasterxml.jackson.core:jackson-annotations:jar:2.21:compile
 				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.25.0:compile
diff --git a/flink-table/flink-table-common/src/main/java/org/apache/flink/table/functions/BuiltInFunctionDefinitions.java b/flink-table/flink-table-common/src/main/java/org/apache/flink/table/functions/BuiltInFunctionDefinitions.java
index 1d842767252db..d611bbc322262 100644
--- a/flink-table/flink-table-common/src/main/java/org/apache/flink/table/functions/BuiltInFunctionDefinitions.java
+++ b/flink-table/flink-table-common/src/main/java/org/apache/flink/table/functions/BuiltInFunctionDefinitions.java
@@ -2887,7 +2887,7 @@ ANY, and(logical(LogicalTypeRoot.BOOLEAN), LITERAL)
                                     sequence(
                                             logical(LogicalTypeFamily.CHARACTER_STRING),
                                             symbol(JsonType.class))))
-                    .outputTypeStrategy(explicit(BOOLEAN().notNull()))
+                    .outputTypeStrategy(explicit(BOOLEAN()))
                     .runtimeDeferred()
                     .build();
 
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/plan/RelOptUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/plan/RelOptUtil.java
index 05fdcfc7ed589..4cb6744d859b1 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/plan/RelOptUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/plan/RelOptUtil.java
@@ -53,13 +53,16 @@
 import org.apache.calcite.rel.hint.Hintable;
 import org.apache.calcite.rel.hint.RelHint;
 import org.apache.calcite.rel.logical.LogicalAggregate;
+import org.apache.calcite.rel.logical.LogicalAsofJoin;
 import org.apache.calcite.rel.logical.LogicalCalc;
 import org.apache.calcite.rel.logical.LogicalFilter;
 import org.apache.calcite.rel.logical.LogicalJoin;
 import org.apache.calcite.rel.logical.LogicalProject;
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.rel.rules.CoreRules;
+import org.apache.calcite.rel.rules.FilterProjectTransposeRule;
 import org.apache.calcite.rel.rules.MultiJoin;
+import org.apache.calcite.rel.rules.ProjectMergeRule;
 import org.apache.calcite.rel.stream.StreamRules;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
@@ -120,6 +123,7 @@
 import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.Deque;
 import java.util.HashMap;
@@ -134,6 +138,7 @@
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
+import static com.google.common.base.Preconditions.checkArgument;
 import static java.util.Objects.requireNonNull;
 import static org.apache.calcite.rel.type.RelDataTypeImpl.NON_NULLABLE_SUFFIX;
 
@@ -147,6 +152,17 @@ public abstract class RelOptUtil {
 
     public static final double EPSILON = 1.0e-5;
 
+    /**
+     * Default amount by which the complexity of a {@link Project} or {@link Filter} may increase
+     * when applying a rule. (Complexity is, roughly, the number of {@link RexNode}s in all
+     * expressions.)
+     *
+     * @see ProjectMergeRule.Config#bloat()
+     * @see FilterProjectTransposeRule.Config#bloat()
+     * @see RelBuilder.Config#bloat()
+     */
+    public static final int DEFAULT_BLOAT = 100;
+
     @SuppressWarnings("Guava")
     @Deprecated // to be removed before 2.0
     public static final com.google.common.base.Predicate<Filter> FILTER_PREDICATE =
@@ -232,11 +248,11 @@ public static Set<CorrelationId> getVariablesSet(RelNode rel) {
     @SuppressWarnings("MixedMutabilityReturnType")
     public static List<CorrelationId> getVariablesSetAndUsed(RelNode rel0, RelNode rel1) {
         Set<CorrelationId> set = getVariablesSet(rel0);
-        if (set.size() == 0) {
+        if (set.isEmpty()) {
             return ImmutableList.of();
         }
         Set<CorrelationId> used = getVariablesUsed(rel1);
-        if (used.size() == 0) {
+        if (used.isEmpty()) {
             return ImmutableList.of();
         }
         final List<CorrelationId> result = new ArrayList<>();
@@ -382,7 +398,7 @@ public static void verifyTypeEquivalence(
                         + "\nexpression type is "
                         + actualRowType.getFullTypeString()
                         + "\nset is "
-                        + equivalenceClass.toString()
+                        + equivalenceClass
                         + "\nexpression is "
                         + RelOptUtil.toString(newRel)
                         + getFullTypeDifferenceString(
@@ -422,7 +438,7 @@ public static void verifyTypeEquivalence(
      */
     @Experimental
     public static RelNode propagateRelHints(RelNode originalRel, RelNode equiv) {
-        if (!(originalRel instanceof Hintable) || ((Hintable) originalRel).getHints().size() == 0) {
+        if (!(originalRel instanceof Hintable) || ((Hintable) originalRel).getHints().isEmpty()) {
             return equiv;
         }
         final RelShuttle shuttle =
@@ -483,7 +499,7 @@ public static RelNode copyRelHints(RelNode originalRel, RelNode newRel, boolean
 
         if (originalRel instanceof Hintable
                 && newRel instanceof Hintable
-                && ((Hintable) originalRel).getHints().size() > 0) {
+                && !((Hintable) originalRel).getHints().isEmpty()) {
             final List<RelHint> hints = ((Hintable) originalRel).getHints();
             if (filterHints) {
                 HintStrategyTable hintStrategies = originalRel.getCluster().getHintStrategies();
@@ -570,7 +586,7 @@ public static RelNode createExistsPlan(
         assert extraExpr == null || extraName != null;
         RelNode ret = seekRel;
 
-        if ((conditions != null) && (conditions.size() > 0)) {
+        if (conditions != null && !conditions.isEmpty()) {
             RexNode conditionExp =
                     RexUtil.composeConjunction(cluster.getRexBuilder(), conditions, true);
 
@@ -837,7 +853,7 @@ public static RelNode createCastRel(
             RelDataType castRowType,
             boolean rename,
             RelFactories.ProjectFactory projectFactory) {
-        assert projectFactory != null;
+        requireNonNull(projectFactory, "projectFactory");
         RelDataType rowType = rel.getRowType();
         if (areRowTypesEqual(rowType, castRowType, rename)) {
             // nothing to do
@@ -891,8 +907,7 @@ public static Set<Integer> getAllFields(Aggregate aggregate) {
     /** Gets all fields in an aggregate. */
     public static Set<Integer> getAllFields2(
             ImmutableBitSet groupSet, List<AggregateCall> aggCallList) {
-        final Set<Integer> allFields = new TreeSet<>();
-        allFields.addAll(groupSet.asList());
+        final Set<Integer> allFields = new TreeSet<>(groupSet.asList());
         for (AggregateCall aggregateCall : aggCallList) {
             allFields.addAll(aggregateCall.getArgList());
             if (aggregateCall.filterArg >= 0) {
@@ -1070,7 +1085,7 @@ public static boolean isEqui(RelNode left, RelNode right, RexNode condition) {
                 rightKeys,
                 filterNulls,
                 nonEquiList);
-        return nonEquiList.size() == 0;
+        return nonEquiList.isEmpty();
     }
 
     /**
@@ -1999,7 +2014,7 @@ public static String dumpPlan(
             String header, RelNode rel, SqlExplainFormat format, SqlExplainLevel detailLevel) {
         StringWriter sw = new StringWriter();
         PrintWriter pw = new PrintWriter(sw);
-        if (!header.equals("")) {
+        if (!header.isEmpty()) {
             pw.println(header);
         }
         RelWriter planWriter;
@@ -2255,8 +2270,8 @@ public static RexNode isDistinctFrom(RexBuilder rexBuilder, RexNode x, RexNode y
 
         // The result of IS DISTINCT FROM is NOT NULL because it can
         // only return TRUE or FALSE.
-        assert ret != null;
-        assert !ret.getType().isNullable();
+        requireNonNull(ret, "ret");
+        checkArgument(!ret.getType().isNullable());
 
         return ret;
     }
@@ -3023,6 +3038,16 @@ public static List<RexNode> pushPastProject(List<? extends RexNode> nodes, Proje
         return pushShuttle(project).visitList(nodes);
     }
 
+    public static @Nullable RexNode pushPastProjectUnlessBloat(
+            RexNode node, Project project, int bloat) {
+        List<RexNode> newConditions =
+                pushPastProjectUnlessBloat(Collections.singletonList(node), project, bloat);
+        if (newConditions == null || newConditions.size() != 1) {
+            return null;
+        }
+        return newConditions.get(0);
+    }
+
     /**
      * As {@link #pushPastProject}, but returns null if the resulting expressions are significantly
      * more complex.
@@ -3509,7 +3534,7 @@ public static boolean notContainsWindowedAgg(Calc calc) {
         return !calc.containsOver();
     }
 
-    /** Predicate for if a {@link Filter} does not windowed aggregates. */
+    /** Predicate for if a {@link Filter} does not contain windowed aggregates. */
     public static boolean notContainsWindowedAgg(Filter filter) {
         return !filter.containsOver();
     }
@@ -3664,14 +3689,22 @@ public static RelNode pushDownJoinConditions(Join originalJoin, RelBuilder relBu
 
         final RelNode right = relBuilder.build();
         final RelNode left = relBuilder.build();
-        relBuilder.push(
-                originalJoin.copy(
-                        originalJoin.getTraitSet(),
-                        joinCond,
-                        left,
-                        right,
-                        joinType,
-                        originalJoin.isSemiJoinDone()));
+        if (joinType == JoinRelType.ASOF || joinType == JoinRelType.LEFT_ASOF) {
+            LogicalAsofJoin ljoin = (LogicalAsofJoin) originalJoin;
+            RexNode match =
+                    RexUtil.shift(ljoin.getMatchCondition(), leftCount, extraLeftExprs.size());
+            RelNode copy = ljoin.copy(originalJoin.getTraitSet(), joinCond, match, left, right);
+            relBuilder.push(copy);
+        } else {
+            relBuilder.push(
+                    originalJoin.copy(
+                            originalJoin.getTraitSet(),
+                            joinCond,
+                            left,
+                            right,
+                            joinType,
+                            originalJoin.isSemiJoinDone()));
+        }
         if (!extraLeftExprs.isEmpty() || !extraRightExprs.isEmpty()) {
             final int totalFields =
                     joinType.projectsRight()
@@ -3834,10 +3867,7 @@ private static void fix(List<RexNode> operands, int before, int after) {
         if (before == after) {
             return;
         }
-        for (int i = 0; i < operands.size(); i++) {
-            RexNode node = operands.get(i);
-            operands.set(i, RexUtil.shift(node, before, after - before));
-        }
+        operands.replaceAll(e -> RexUtil.shift(e, before, after - before));
     }
 
     /**
@@ -3987,7 +4017,7 @@ public RelNode visit(RelNode other) {
          */
         private RelNode visitHintable(RelNode node) {
             final List<RelHint> topHints = ((Hintable) node).getHints();
-            final boolean hasHints = topHints != null && topHints.size() > 0;
+            final boolean hasHints = !topHints.isEmpty();
             final boolean hasQueryHints = hasHints && !(node instanceof TableScan);
             if (hasQueryHints) {
                 inheritPaths.push(Pair.of(topHints, new ArrayDeque<>()));
@@ -4001,7 +4031,7 @@ private RelNode visitHintable(RelNode node) {
 
         private RelNode attachHints(RelNode original) {
             assert original instanceof Hintable;
-            if (inheritPaths.size() > 0) {
+            if (!inheritPaths.isEmpty()) {
                 final List<RelHint> hints =
                         inheritPaths.stream()
                                 .sorted(Comparator.comparingInt(o -> o.right.size()))
@@ -4013,7 +4043,7 @@ private RelNode attachHints(RelNode original) {
                                             return acc;
                                         });
                 final List<RelHint> filteredHints = hintStrategies.apply(hints, original);
-                if (filteredHints.size() > 0) {
+                if (!filteredHints.isEmpty()) {
                     return ((Hintable) original).attachHints(filteredHints);
                 }
             }
@@ -4120,7 +4150,7 @@ public RelNode visit(RelNode other) {
          */
         private RelNode visitHintable(RelNode node) {
             final List<RelHint> topHints = ((Hintable) node).getHints();
-            final boolean hasHints = topHints != null && topHints.size() > 0;
+            final boolean hasHints = !topHints.isEmpty();
             if (hasHints) {
                 // This node is definitely not created by the planner, returns early.
                 return node;
@@ -4139,14 +4169,14 @@ private RelNode attachHints(RelNode original) {
                             .map(hint -> copyWithAppendPath(hint, appendPath))
                             .collect(Collectors.toList());
             final List<RelHint> filteredHints = hintStrategies.apply(hints, original);
-            if (filteredHints.size() > 0) {
+            if (!filteredHints.isEmpty()) {
                 return ((Hintable) original).attachHints(filteredHints);
             }
             return original;
         }
 
         private static RelHint copyWithAppendPath(RelHint hint, List<Integer> appendPaths) {
-            if (appendPaths.size() == 0) {
+            if (appendPaths.isEmpty()) {
                 return hint;
             } else {
                 List<Integer> newPath = new ArrayList<>(hint.inheritPath);
@@ -4183,15 +4213,14 @@ public RelNode visit(RelNode node) {
         }
 
         private static RelNode resetHints(Hintable hintable) {
-            if (hintable.getHints().size() > 0) {
-                final List<RelHint> resetHints =
-                        hintable.getHints().stream()
-                                .filter(hint -> hint.inheritPath.size() == 0)
-                                .collect(Collectors.toList());
-                return hintable.withHints(resetHints);
-            } else {
+            if (hintable.getHints().isEmpty()) {
                 return (RelNode) hintable;
             }
+            final List<RelHint> resetHints =
+                    hintable.getHints().stream()
+                            .filter(hint -> hint.inheritPath.isEmpty())
+                            .collect(Collectors.toList());
+            return hintable.withHints(resetHints);
         }
     }
 
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/metadata/RelMdPredicates.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/metadata/RelMdPredicates.java
deleted file mode 100644
index de3d4a6deaa2b..0000000000000
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/metadata/RelMdPredicates.java
+++ /dev/null
@@ -1,1051 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.rel.metadata;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
-import org.apache.calcite.linq4j.Ord;
-import org.apache.calcite.plan.RelOptCluster;
-import org.apache.calcite.plan.RelOptPredicateList;
-import org.apache.calcite.plan.RelOptUtil;
-import org.apache.calcite.plan.RexImplicationChecker;
-import org.apache.calcite.plan.Strong;
-import org.apache.calcite.plan.volcano.RelSubset;
-import org.apache.calcite.rel.RelNode;
-import org.apache.calcite.rel.core.Aggregate;
-import org.apache.calcite.rel.core.AggregateCall;
-import org.apache.calcite.rel.core.Correlate;
-import org.apache.calcite.rel.core.Exchange;
-import org.apache.calcite.rel.core.Filter;
-import org.apache.calcite.rel.core.Intersect;
-import org.apache.calcite.rel.core.Join;
-import org.apache.calcite.rel.core.JoinRelType;
-import org.apache.calcite.rel.core.Minus;
-import org.apache.calcite.rel.core.Project;
-import org.apache.calcite.rel.core.Sample;
-import org.apache.calcite.rel.core.Sort;
-import org.apache.calcite.rel.core.TableModify;
-import org.apache.calcite.rel.core.TableScan;
-import org.apache.calcite.rel.core.Union;
-import org.apache.calcite.rel.core.Values;
-import org.apache.calcite.rex.RexBuilder;
-import org.apache.calcite.rex.RexCall;
-import org.apache.calcite.rex.RexExecutor;
-import org.apache.calcite.rex.RexInputRef;
-import org.apache.calcite.rex.RexLiteral;
-import org.apache.calcite.rex.RexNode;
-import org.apache.calcite.rex.RexPermuteInputsShuttle;
-import org.apache.calcite.rex.RexSimplify;
-import org.apache.calcite.rex.RexUnknownAs;
-import org.apache.calcite.rex.RexUtil;
-import org.apache.calcite.rex.RexVisitorImpl;
-import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.fun.SqlInternalOperators;
-import org.apache.calcite.sql.fun.SqlStdOperatorTable;
-import org.apache.calcite.util.BitSets;
-import org.apache.calcite.util.Bug;
-import org.apache.calcite.util.ImmutableBitSet;
-import org.apache.calcite.util.Util;
-import org.apache.calcite.util.mapping.Mapping;
-import org.apache.calcite.util.mapping.MappingType;
-import org.apache.calcite.util.mapping.Mappings;
-import org.checkerframework.checker.nullness.qual.Nullable;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.BitSet;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Set;
-import java.util.SortedMap;
-import java.util.TreeMap;
-import java.util.stream.Collectors;
-
-import static java.util.Objects.requireNonNull;
-
-/**
- * Utility to infer Predicates that are applicable above a RelNode.
- *
- * <p>This is currently used by {@link
- * org.apache.calcite.rel.rules.JoinPushTransitivePredicatesRule} to infer <em>Predicates</em> that
- * can be inferred from one side of a Join to the other.
- *
- * <p>The PullUp Strategy is sound but not complete. Here are some of the limitations:
- *
- * <ol>
- *   <li>For Aggregations we only PullUp predicates that only contain Grouping Keys. This can be
- *       extended to infer predicates on Aggregation expressions from expressions on the aggregated
- *       columns. For e.g.
- *       <pre>
- * select a, max(b) from R1 where b &gt; 7
- *   &rarr; max(b) &gt; 7 or max(b) is null
- * </pre>
- *   <li>For Projections we only look at columns that are projected without any function applied.
- *       So:
- *       <pre>
- * select a from R1 where a &gt; 7
- *   &rarr; "a &gt; 7" is pulled up from the Projection.
- * select a + 1 from R1 where a + 1 &gt; 7
- *   &rarr; "a + 1 gt; 7" is not pulled up
- * </pre>
- *   <li>There are several restrictions on Joins:
- *       <ul>
- *         <li>We only pullUp inferred predicates for now. Pulling up existing predicates causes an
- *             explosion of duplicates. The existing predicates are pushed back down as new
- *             predicates. Once we have rules to eliminate duplicate Filter conditions, we should
- *             pullUp all predicates.
- *         <li>For Left Outer: we infer new predicates from the left and set them as applicable on
- *             the Right side. No predicates are pulledUp.
- *         <li>Right Outer Joins are handled in an analogous manner.
- *         <li>For Full Outer Joins no predicates are pulledUp or inferred.
- *       </ul>
- * </ol>
- *
- * The class contains CALCITE-6599 fix from 1.39.0, should be dropped after upgrade to that version
- *
- * <p>Lines 181 ~ 217
- *
- * <p>Lines 560 ~ 562 disable CALCITE-6044 optimization
- */
-public class RelMdPredicates implements MetadataHandler<BuiltInMetadata.Predicates> {
-    public static final RelMetadataProvider SOURCE =
-            ReflectiveRelMetadataProvider.reflectiveSource(
-                    new RelMdPredicates(), BuiltInMetadata.Predicates.Handler.class);
-
-    private static final List<RexNode> EMPTY_LIST = ImmutableList.of();
-
-    @Override
-    public MetadataDef<BuiltInMetadata.Predicates> getDef() {
-        return BuiltInMetadata.Predicates.DEF;
-    }
-
-    /**
-     * Catch-all implementation for {@link BuiltInMetadata.Predicates#getPredicates()}, invoked
-     * using reflection.
-     *
-     * @see org.apache.calcite.rel.metadata.RelMetadataQuery#getPulledUpPredicates(RelNode)
-     */
-    public RelOptPredicateList getPredicates(RelNode rel, RelMetadataQuery mq) {
-        return RelOptPredicateList.EMPTY;
-    }
-
-    /** Infers predicates for a table scan. */
-    public RelOptPredicateList getPredicates(TableScan scan, RelMetadataQuery mq) {
-        final BuiltInMetadata.Predicates.Handler handler =
-                scan.getTable().unwrap(BuiltInMetadata.Predicates.Handler.class);
-        if (handler != null) {
-            return handler.getPredicates(scan, mq);
-        }
-        return RelOptPredicateList.EMPTY;
-    }
-
-    /**
-     * Infers predicates for a project.
-     *
-     * <ol>
-     *   <li>create a mapping from input to projection. Map only positions that directly reference
-     *       an input column.
-     *   <li>Expressions that only contain above columns are retained in the Project's
-     *       pullExpressions list.
-     *   <li>For e.g. expression 'a + e = 9' below will not be pulled up because 'e' is not in the
-     *       projection list.
-     *       <blockquote>
-     *       <pre>
-     * inputPullUpExprs:      {a &gt; 7, b + c &lt; 10, a + e = 9}
-     * projectionExprs:       {a, b, c, e / 2}
-     * projectionPullupExprs: {a &gt; 7, b + c &lt; 10}
-     * </pre>
-     *       </blockquote>
-     * </ol>
-     */
-    public RelOptPredicateList getPredicates(Project project, RelMetadataQuery mq) {
-        // FLINK MODIFICATION BEGIN
-        final RelNode input = project.getInput();
-        final RexBuilder rexBuilder = project.getCluster().getRexBuilder();
-        final RelOptPredicateList inputInfo = mq.getPulledUpPredicates(input);
-        final List<RexNode> projectPullUpPredicates = new ArrayList<>();
-
-        ImmutableBitSet.Builder columnsMappedBuilder = ImmutableBitSet.builder();
-        Mapping m =
-                Mappings.create(
-                        MappingType.PARTIAL_FUNCTION,
-                        input.getRowType().getFieldCount(),
-                        project.getRowType().getFieldCount());
-
-        for (Ord<RexNode> expr : Ord.zip(project.getProjects())) {
-            if (expr.e instanceof RexInputRef) {
-                int sIdx = ((RexInputRef) expr.e).getIndex();
-                m.set(sIdx, expr.i);
-                columnsMappedBuilder.set(sIdx);
-            } else if (RexUtil.isConstant(expr.e)) {
-                // Project can also generate constants (including NULL). We need to
-                // include them.
-                projectPullUpPredicates.add(eqConstant(project, rexBuilder, expr.i, expr.e));
-            }
-        }
-
-        // Go over childPullUpPredicates. If a predicate only contains columns in
-        // 'columnsMapped' construct a new predicate based on mapping.
-        final ImmutableBitSet columnsMapped = columnsMappedBuilder.build();
-        for (RexNode r : inputInfo.pulledUpPredicates) {
-            RexNode r2 = projectPredicate(rexBuilder, input, r, columnsMapped);
-            if (!r2.isAlwaysTrue()) {
-                r2 = r2.accept(new RexPermuteInputsShuttle(m, input));
-                projectPullUpPredicates.add(r2);
-            }
-        }
-        return RelOptPredicateList.of(rexBuilder, projectPullUpPredicates);
-        // FLINK MODIFICATION END
-    }
-
-    /**
-     * Returns a predicate that field {@code i} of relational expression {@code r} is equal to a
-     * constant expression (using {@code IS NOT DISTINCT FROM} if the expression is nullable, or
-     * {@code IS NULL} if it is literal null.
-     */
-    private static RexNode eqConstant(RelNode r, RexBuilder rexBuilder, int i, RexNode e) {
-        final RexInputRef ref = rexBuilder.makeInputRef(r, i);
-        if (RexLiteral.isNullLiteral(e)) {
-            return rexBuilder.makeCall(SqlStdOperatorTable.IS_NULL, ref);
-        } else if (ref.getType().isNullable() || e.getType().isNullable()) {
-            return rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_DISTINCT_FROM, ref, e);
-        } else {
-            return rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, ref, e);
-        }
-    }
-
-    /**
-     * Converts a predicate on a particular set of columns into a predicate on a subset of those
-     * columns, weakening if necessary.
-     *
-     * <p>If not possible to simplify, returns {@code true}, which is the weakest possible
-     * predicate.
-     *
-     * <p>Examples:
-     *
-     * <ol>
-     *   <li>The predicate {@code $7 = $9} on columns [7] becomes {@code $7 is not null}
-     *   <li>The predicate {@code $7 = $9 + $11} on columns [7, 9] becomes {@code $7 is not null or
-     *       $9 is not null}
-     *   <li>The predicate {@code $7 = $9 and $9 = 5} on columns [7] becomes {@code $7 = 5}
-     *   <li>The predicate {@code $7 = $9 and ($9 = $1 or $9 = $2) and $1 > 3 and $2 > 10} on
-     *       columns [7] becomes {@code $7 > 3}
-     * </ol>
-     *
-     * <p>We currently only handle examples 1 and 2.
-     *
-     * @param rexBuilder Rex builder
-     * @param input Input relational expression
-     * @param r Predicate expression
-     * @param columnsMapped Columns which the final predicate can reference
-     * @return Predicate expression narrowed to reference only certain columns
-     */
-    private static RexNode projectPredicate(
-            final RexBuilder rexBuilder, RelNode input, RexNode r, ImmutableBitSet columnsMapped) {
-        ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r);
-        if (columnsMapped.contains(rCols)) {
-            // All required columns are present. No need to weaken.
-            return r;
-        }
-        if (columnsMapped.intersects(rCols)) {
-            final List<RexNode> list = new ArrayList<>();
-            for (int c : columnsMapped.intersect(rCols)) {
-                if (input.getRowType().getFieldList().get(c).getType().isNullable()
-                        && Strong.isNull(r, ImmutableBitSet.of(c))) {
-                    list.add(
-                            rexBuilder.makeCall(
-                                    SqlStdOperatorTable.IS_NOT_NULL,
-                                    rexBuilder.makeInputRef(input, c)));
-                }
-            }
-            if (!list.isEmpty()) {
-                return RexUtil.composeDisjunction(rexBuilder, list);
-            }
-        }
-        // Cannot weaken to anything non-trivial
-        return rexBuilder.makeLiteral(true);
-    }
-
-    /** Infers predicates for a correlate node. */
-    public RelOptPredicateList getPredicates(Correlate correlate, RelMetadataQuery mq) {
-        return mq.getPulledUpPredicates(correlate.getLeft());
-    }
-
-    /** Add the Filter condition to the pulledPredicates list from the input. */
-    public RelOptPredicateList getPredicates(Filter filter, RelMetadataQuery mq) {
-        final RelNode input = filter.getInput();
-        final RexBuilder rexBuilder = filter.getCluster().getRexBuilder();
-        final RelOptPredicateList inputInfo = mq.getPulledUpPredicates(input);
-
-        // Simplify condition using RexSimplify.
-        final RexNode condition = filter.getCondition();
-        final RexExecutor executor =
-                Util.first(filter.getCluster().getPlanner().getExecutor(), RexUtil.EXECUTOR);
-        final RexSimplify simplify =
-                new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, executor);
-        final RexNode simplifiedCondition = simplify.simplify(condition);
-
-        return Util.first(inputInfo, RelOptPredicateList.EMPTY)
-                .union(
-                        rexBuilder,
-                        RelOptPredicateList.of(
-                                rexBuilder,
-                                RexUtil.retainDeterministic(
-                                        RelOptUtil.conjunctions(simplifiedCondition))));
-    }
-
-    /**
-     * Infers predicates for a {@link org.apache.calcite.rel.core.Join} (including {@code
-     * SemiJoin}).
-     */
-    public RelOptPredicateList getPredicates(Join join, RelMetadataQuery mq) {
-        RelOptCluster cluster = join.getCluster();
-        RexBuilder rexBuilder = cluster.getRexBuilder();
-        final RexExecutor executor =
-                Util.first(cluster.getPlanner().getExecutor(), RexUtil.EXECUTOR);
-        final RelNode left = join.getInput(0);
-        final RelNode right = join.getInput(1);
-
-        final RelOptPredicateList leftInfo = mq.getPulledUpPredicates(left);
-        final RelOptPredicateList rightInfo = mq.getPulledUpPredicates(right);
-
-        JoinConditionBasedPredicateInference joinInference =
-                new JoinConditionBasedPredicateInference(
-                        join,
-                        RexUtil.composeConjunction(rexBuilder, leftInfo.pulledUpPredicates),
-                        RexUtil.composeConjunction(rexBuilder, rightInfo.pulledUpPredicates),
-                        new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, executor));
-
-        return joinInference.inferPredicates(false);
-    }
-
-    /**
-     * Check whether the fields specified by the predicateColumns appear in all the groupSets of the
-     * aggregate.
-     *
-     * @param predicateColumns A list of columns used in a pulled predicate.
-     * @param aggregate An aggregation operation.
-     * @return Whether all columns appear in all groupsets.
-     */
-    boolean allGroupSetsOverlap(ImmutableBitSet predicateColumns, Aggregate aggregate) {
-        // Consider this example:
-        // select deptno, sal, count(*)
-        // from emp where deptno = 10
-        // group by rollup(sal, deptno)
-        // Because of the ROLLUP, we cannot assume
-        // that deptno = 10 in the result: deptno may be NULL as well.
-        for (ImmutableBitSet groupSet : aggregate.groupSets) {
-            if (!groupSet.contains(predicateColumns)) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Infers predicates for an Aggregate.
-     *
-     * <p>Pulls up predicates that only contains references to columns in the GroupSet. For e.g.
-     *
-     * <blockquote>
-     *
-     * <pre>
-     * inputPullUpExprs : { a &gt; 7, b + c &lt; 10, a + e = 9}
-     * groupSet         : { a, b}
-     * pulledUpExprs    : { a &gt; 7}
-     * </pre>
-     *
-     * </blockquote>
-     */
-    public RelOptPredicateList getPredicates(Aggregate agg, RelMetadataQuery mq) {
-        final RelNode input = agg.getInput();
-        final RexBuilder rexBuilder = agg.getCluster().getRexBuilder();
-        final RelOptPredicateList inputInfo = mq.getPulledUpPredicates(input);
-        final List<RexNode> aggPullUpPredicates = new ArrayList<>();
-
-        ImmutableBitSet groupKeys = agg.getGroupSet();
-        if (groupKeys.isEmpty()) {
-            // "GROUP BY ()" can convert an empty relation to a non-empty relation, so
-            // it is not valid to pull up predicates. In particular, consider the
-            // predicate "false": it is valid on all input rows (trivially - there are
-            // no rows!) but not on the output (there is one row).
-            return RelOptPredicateList.of(rexBuilder, aggPullUpPredicates);
-        }
-        Mapping m =
-                Mappings.create(
-                        MappingType.PARTIAL_FUNCTION,
-                        input.getRowType().getFieldCount(),
-                        agg.getRowType().getFieldCount());
-
-        int i = 0;
-        for (int j : groupKeys) {
-            m.set(j, i++);
-        }
-
-        for (RexNode r : inputInfo.pulledUpPredicates) {
-            ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r);
-
-            if (groupKeys.contains(rCols) && this.allGroupSetsOverlap(rCols, agg)) {
-                r = r.accept(new RexPermuteInputsShuttle(m, input));
-                aggPullUpPredicates.add(r);
-            }
-        }
-
-        i = agg.getGroupCount();
-        for (AggregateCall aggregateCall : agg.getAggCallList()) {
-            if (aggregateCall.getAggregation() == SqlInternalOperators.LITERAL_AGG) {
-                // The query
-                //   SELECT x, LITERAL_AGG[42]() AS y FROM t GROUP BY x
-                // has predicate "y = 42"
-                aggPullUpPredicates.add(
-                        eqConstant(agg, rexBuilder, i, aggregateCall.rexList.get(0)));
-            }
-            ++i;
-        }
-        return RelOptPredicateList.of(rexBuilder, aggPullUpPredicates);
-    }
-
-    /** Infers predicates for a Union. */
-    public RelOptPredicateList getPredicates(Union union, RelMetadataQuery mq) {
-        final RexBuilder rexBuilder = union.getCluster().getRexBuilder();
-
-        Set<RexNode> finalPredicates = new HashSet<>();
-        final List<RexNode> finalResidualPredicates = new ArrayList<>();
-        for (Ord<RelNode> input : Ord.zip(union.getInputs())) {
-            RelOptPredicateList info = mq.getPulledUpPredicates(input.e);
-            if (info.pulledUpPredicates.isEmpty()) {
-                return RelOptPredicateList.EMPTY;
-            }
-            final Set<RexNode> predicates = new HashSet<>();
-            final List<RexNode> residualPredicates = new ArrayList<>();
-            for (RexNode pred : info.pulledUpPredicates) {
-                if (input.i == 0) {
-                    predicates.add(pred);
-                    continue;
-                }
-                if (finalPredicates.contains(pred)) {
-                    predicates.add(pred);
-                } else {
-                    residualPredicates.add(pred);
-                }
-            }
-            // Add new residual predicates
-            finalResidualPredicates.add(RexUtil.composeConjunction(rexBuilder, residualPredicates));
-            // Add those that are not part of the final set to residual
-            for (RexNode e : finalPredicates) {
-                if (!predicates.contains(e)) {
-                    // This node was in previous union inputs, but it is not in this one
-                    for (int j = 0; j < input.i; j++) {
-                        finalResidualPredicates.set(
-                                j,
-                                RexUtil.composeConjunction(
-                                        rexBuilder,
-                                        Arrays.asList(finalResidualPredicates.get(j), e)));
-                    }
-                }
-            }
-            // Final predicates
-            finalPredicates = predicates;
-        }
-
-        final List<RexNode> predicates = new ArrayList<>(finalPredicates);
-        final RelOptCluster cluster = union.getCluster();
-        final RexExecutor executor =
-                Util.first(cluster.getPlanner().getExecutor(), RexUtil.EXECUTOR);
-        RexNode disjunctivePredicate =
-                new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, executor)
-                        .simplifyUnknownAs(
-                                rexBuilder.makeCall(
-                                        SqlStdOperatorTable.OR, finalResidualPredicates),
-                                RexUnknownAs.FALSE);
-        if (!disjunctivePredicate.isAlwaysTrue()) {
-            predicates.add(disjunctivePredicate);
-        }
-        return RelOptPredicateList.of(rexBuilder, predicates);
-    }
-
-    /** Infers predicates for a Intersect. */
-    public RelOptPredicateList getPredicates(Intersect intersect, RelMetadataQuery mq) {
-        final RexBuilder rexBuilder = intersect.getCluster().getRexBuilder();
-
-        final RexExecutor executor =
-                Util.first(intersect.getCluster().getPlanner().getExecutor(), RexUtil.EXECUTOR);
-
-        final RexImplicationChecker rexImplicationChecker =
-                new RexImplicationChecker(rexBuilder, executor, intersect.getRowType());
-
-        Set<RexNode> finalPredicates = new HashSet<>();
-
-        for (Ord<RelNode> input : Ord.zip(intersect.getInputs())) {
-            RelOptPredicateList info = mq.getPulledUpPredicates(input.e);
-            if (info == null || info.pulledUpPredicates.isEmpty()) {
-                continue;
-            }
-
-            for (RexNode pred : info.pulledUpPredicates) {
-                if (finalPredicates.stream()
-                        .anyMatch(finalPred -> rexImplicationChecker.implies(finalPred, pred))) {
-                    // There's already a stricter predicate in finalPredicates,
-                    // thus no need to count this one.
-                    continue;
-                }
-                // Remove looser predicate and add this one into finalPredicates
-                finalPredicates =
-                        finalPredicates.stream()
-                                .filter(
-                                        finalPred ->
-                                                !rexImplicationChecker.implies(pred, finalPred))
-                                .collect(Collectors.toSet());
-                finalPredicates.add(pred);
-            }
-        }
-
-        return RelOptPredicateList.of(rexBuilder, finalPredicates);
-    }
-
-    /** Infers predicates for a Minus. */
-    public RelOptPredicateList getPredicates(Minus minus, RelMetadataQuery mq) {
-        return mq.getPulledUpPredicates(minus.getInput(0));
-    }
-
-    /** Infers predicates for a Sample. */
-    public RelOptPredicateList getPredicates(Sample sample, RelMetadataQuery mq) {
-        RelNode input = sample.getInput();
-        return mq.getPulledUpPredicates(input);
-    }
-
-    /** Infers predicates for a Sort. */
-    public RelOptPredicateList getPredicates(Sort sort, RelMetadataQuery mq) {
-        RelNode input = sort.getInput();
-        return mq.getPulledUpPredicates(input);
-    }
-
-    /** Infers predicates for a TableModify. */
-    public RelOptPredicateList getPredicates(TableModify tableModify, RelMetadataQuery mq) {
-        return mq.getPulledUpPredicates(tableModify.getInput());
-    }
-
-    /** Infers predicates for an Exchange. */
-    public RelOptPredicateList getPredicates(Exchange exchange, RelMetadataQuery mq) {
-        RelNode input = exchange.getInput();
-        return mq.getPulledUpPredicates(input);
-    }
-
-    /**
-     * Infers predicates for a Values.
-     *
-     * <p>The predicates on {@code T (x, y, z)} with rows {@code (1, 2, null), (1, 2, null), (5, 2,
-     * null)} are {@code 'y = 2'} and {@code 'z is null'}.
-     */
-    public RelOptPredicateList getPredicates(Values values, RelMetadataQuery mq) {
-        // FLINK MODIFICATION BEGIN
-        return RelOptPredicateList.EMPTY;
-        // FLINK MODIFICATION END
-    }
-
-    // CHECKSTYLE: IGNORE 1
-    /**
-     * Returns the {@link BuiltInMetadata.Predicates#getPredicates()} statistic.
-     *
-     * @see RelMetadataQuery#getPulledUpPredicates(RelNode)
-     */
-    public RelOptPredicateList getPredicates(RelSubset r, RelMetadataQuery mq) {
-        if (!Bug.CALCITE_1048_FIXED) {
-            return RelOptPredicateList.EMPTY;
-        }
-        final RexBuilder rexBuilder = r.getCluster().getRexBuilder();
-        RelOptPredicateList list = null;
-        for (RelNode r2 : r.getRels()) {
-            RelOptPredicateList list2 = mq.getPulledUpPredicates(r2);
-            if (list2 != null) {
-                list = list == null ? list2 : list.union(rexBuilder, list2);
-            }
-        }
-        return Util.first(list, RelOptPredicateList.EMPTY);
-    }
-
-    /**
-     * Utility to infer predicates from one side of the join that apply on the other side.
-     *
-     * <p>Contract is:
-     *
-     * <ul>
-     *   <li>initialize with a {@link org.apache.calcite.rel.core.Join} and optional predicates
-     *       applicable on its left and right subtrees.
-     *   <li>you can then ask it for equivalentPredicate(s) given a predicate.
-     * </ul>
-     *
-     * <p>So for:
-     *
-     * <ol>
-     *   <li>'<code>R1(x) join R2(y) on x = y</code>' a call for equivalentPredicates on '<code>
-     *       x &gt; 7</code>' will return ' <code>[y &gt; 7]</code>'
-     *   <li>'<code>R1(x) join R2(y) on x = y join R3(z) on y = z</code>' a call for
-     *       equivalentPredicates on the second join '<code>x &gt; 7</code>' will return
-     * </ol>
-     */
-    static class JoinConditionBasedPredicateInference {
-        final Join joinRel;
-        final int nSysFields;
-        final int nFieldsLeft;
-        final int nFieldsRight;
-        final ImmutableBitSet leftFieldsBitSet;
-        final ImmutableBitSet rightFieldsBitSet;
-        final ImmutableBitSet allFieldsBitSet;
-
-        @SuppressWarnings("JdkObsolete")
-        SortedMap<Integer, BitSet> equivalence;
-
-        final Map<RexNode, ImmutableBitSet> exprFields;
-        final Set<RexNode> allExprs;
-        final Set<RexNode> equalityPredicates;
-        final @Nullable RexNode leftChildPredicates;
-        final @Nullable RexNode rightChildPredicates;
-        final RexSimplify simplify;
-
-        @SuppressWarnings("JdkObsolete")
-        JoinConditionBasedPredicateInference(
-                Join joinRel,
-                @Nullable RexNode leftPredicates,
-                @Nullable RexNode rightPredicates,
-                RexSimplify simplify) {
-            super();
-            this.joinRel = joinRel;
-            this.simplify = simplify;
-            nFieldsLeft = joinRel.getLeft().getRowType().getFieldList().size();
-            nFieldsRight = joinRel.getRight().getRowType().getFieldList().size();
-            nSysFields = joinRel.getSystemFieldList().size();
-            leftFieldsBitSet = ImmutableBitSet.range(nSysFields, nSysFields + nFieldsLeft);
-            rightFieldsBitSet =
-                    ImmutableBitSet.range(
-                            nSysFields + nFieldsLeft, nSysFields + nFieldsLeft + nFieldsRight);
-            allFieldsBitSet = ImmutableBitSet.range(0, nSysFields + nFieldsLeft + nFieldsRight);
-
-            exprFields = new HashMap<>();
-            allExprs = new HashSet<>();
-
-            if (leftPredicates == null) {
-                leftChildPredicates = null;
-            } else {
-                Mappings.TargetMapping leftMapping =
-                        Mappings.createShiftMapping(
-                                nSysFields + nFieldsLeft, nSysFields, 0, nFieldsLeft);
-                leftChildPredicates =
-                        leftPredicates.accept(
-                                new RexPermuteInputsShuttle(leftMapping, joinRel.getInput(0)));
-
-                allExprs.add(leftChildPredicates);
-                for (RexNode r : RelOptUtil.conjunctions(leftChildPredicates)) {
-                    exprFields.put(r, RelOptUtil.InputFinder.bits(r));
-                    allExprs.add(r);
-                }
-            }
-            if (rightPredicates == null) {
-                rightChildPredicates = null;
-            } else {
-                Mappings.TargetMapping rightMapping =
-                        Mappings.createShiftMapping(
-                                nSysFields + nFieldsLeft + nFieldsRight,
-                                nSysFields + nFieldsLeft,
-                                0,
-                                nFieldsRight);
-                rightChildPredicates =
-                        rightPredicates.accept(
-                                new RexPermuteInputsShuttle(rightMapping, joinRel.getInput(1)));
-
-                allExprs.add(rightChildPredicates);
-                for (RexNode r : RelOptUtil.conjunctions(rightChildPredicates)) {
-                    exprFields.put(r, RelOptUtil.InputFinder.bits(r));
-                    allExprs.add(r);
-                }
-            }
-
-            equivalence = new TreeMap<>();
-            equalityPredicates = new HashSet<>();
-            for (int i = 0; i < nSysFields + nFieldsLeft + nFieldsRight; i++) {
-                equivalence.put(i, BitSets.of(i));
-            }
-
-            // Only process equivalences found in the join conditions. Processing
-            // Equivalences from the left or right side infer predicates that are
-            // already present in the Tree below the join.
-            List<RexNode> exprs = RelOptUtil.conjunctions(joinRel.getCondition());
-
-            final EquivalenceFinder eF = new EquivalenceFinder();
-            exprs.forEach(input -> input.accept(eF));
-
-            equivalence = BitSets.closure(equivalence);
-        }
-
-        /**
-         * The PullUp Strategy is sound but not complete.
-         *
-         * <ol>
-         *   <li>We only pullUp inferred predicates for now. Pulling up existing predicates causes
-         *       an explosion of duplicates. The existing predicates are pushed back down as new
-         *       predicates. Once we have rules to eliminate duplicate Filter conditions, we should
-         *       pullUp all predicates.
-         *   <li>For Left Outer: we infer new predicates from the left and set them as applicable on
-         *       the Right side. No predicates are pulledUp.
-         *   <li>Right Outer Joins are handled in an analogous manner.
-         *   <li>For Full Outer Joins no predicates are pulledUp or inferred.
-         * </ol>
-         */
-        public RelOptPredicateList inferPredicates(boolean includeEqualityInference) {
-            final List<RexNode> inferredPredicates = new ArrayList<>();
-            final Set<RexNode> allExprs = new HashSet<>(this.allExprs);
-            final JoinRelType joinType = joinRel.getJoinType();
-            switch (joinType) {
-                case SEMI:
-                case INNER:
-                case LEFT:
-                case ANTI:
-                    infer(
-                            leftChildPredicates,
-                            allExprs,
-                            inferredPredicates,
-                            includeEqualityInference,
-                            joinType == JoinRelType.LEFT ? rightFieldsBitSet : allFieldsBitSet);
-                    break;
-                default:
-                    break;
-            }
-            switch (joinType) {
-                case SEMI:
-                case INNER:
-                case RIGHT:
-                    infer(
-                            rightChildPredicates,
-                            allExprs,
-                            inferredPredicates,
-                            includeEqualityInference,
-                            joinType == JoinRelType.RIGHT ? leftFieldsBitSet : allFieldsBitSet);
-                    break;
-                default:
-                    break;
-            }
-
-            Mappings.TargetMapping rightMapping =
-                    Mappings.createShiftMapping(
-                            nSysFields + nFieldsLeft + nFieldsRight,
-                            0,
-                            nSysFields + nFieldsLeft,
-                            nFieldsRight);
-            final RexPermuteInputsShuttle rightPermute =
-                    new RexPermuteInputsShuttle(rightMapping, joinRel);
-            Mappings.TargetMapping leftMapping =
-                    Mappings.createShiftMapping(
-                            nSysFields + nFieldsLeft, 0, nSysFields, nFieldsLeft);
-            final RexPermuteInputsShuttle leftPermute =
-                    new RexPermuteInputsShuttle(leftMapping, joinRel);
-            final List<RexNode> leftInferredPredicates = new ArrayList<>();
-            final List<RexNode> rightInferredPredicates = new ArrayList<>();
-
-            for (RexNode iP : inferredPredicates) {
-                ImmutableBitSet iPBitSet = RelOptUtil.InputFinder.bits(iP);
-                if (leftFieldsBitSet.contains(iPBitSet)) {
-                    leftInferredPredicates.add(iP.accept(leftPermute));
-                } else if (rightFieldsBitSet.contains(iPBitSet)) {
-                    rightInferredPredicates.add(iP.accept(rightPermute));
-                }
-            }
-
-            final RexBuilder rexBuilder = joinRel.getCluster().getRexBuilder();
-            switch (joinType) {
-                case SEMI:
-                    Iterable<RexNode> pulledUpPredicates;
-                    pulledUpPredicates =
-                            Iterables.concat(
-                                    RelOptUtil.conjunctions(leftChildPredicates),
-                                    leftInferredPredicates);
-                    return RelOptPredicateList.of(
-                            rexBuilder,
-                            pulledUpPredicates,
-                            leftInferredPredicates,
-                            rightInferredPredicates);
-                case INNER:
-                    pulledUpPredicates =
-                            Iterables.concat(
-                                    RelOptUtil.conjunctions(leftChildPredicates),
-                                    RelOptUtil.conjunctions(rightChildPredicates),
-                                    RexUtil.retainDeterministic(
-                                            RelOptUtil.conjunctions(joinRel.getCondition())),
-                                    inferredPredicates);
-                    return RelOptPredicateList.of(
-                            rexBuilder,
-                            pulledUpPredicates,
-                            leftInferredPredicates,
-                            rightInferredPredicates);
-                case LEFT:
-                case ANTI:
-                    return RelOptPredicateList.of(
-                            rexBuilder,
-                            RelOptUtil.conjunctions(leftChildPredicates),
-                            leftInferredPredicates,
-                            rightInferredPredicates);
-                case RIGHT:
-                    return RelOptPredicateList.of(
-                            rexBuilder,
-                            RelOptUtil.conjunctions(rightChildPredicates),
-                            inferredPredicates,
-                            EMPTY_LIST);
-                default:
-                    assert inferredPredicates.size() == 0;
-                    return RelOptPredicateList.EMPTY;
-            }
-        }
-
-        public @Nullable RexNode left() {
-            return leftChildPredicates;
-        }
-
-        public @Nullable RexNode right() {
-            return rightChildPredicates;
-        }
-
-        private void infer(
-                @Nullable RexNode predicates,
-                Set<RexNode> allExprs,
-                List<RexNode> inferredPredicates,
-                boolean includeEqualityInference,
-                ImmutableBitSet inferringFields) {
-            for (RexNode r : RelOptUtil.conjunctions(predicates)) {
-                if (!includeEqualityInference && equalityPredicates.contains(r)) {
-                    continue;
-                }
-                for (Mapping m : mappings(r)) {
-                    RexNode tr =
-                            r.accept(
-                                    new RexPermuteInputsShuttle(
-                                            m, joinRel.getInput(0), joinRel.getInput(1)));
-                    // Filter predicates can be already simplified, so we should work with
-                    // simplified RexNode versions as well. It also allows prevent of having
-                    // some duplicates in in result pulledUpPredicates
-                    RexNode simplifiedTarget =
-                            simplify.simplifyFilterPredicates(RelOptUtil.conjunctions(tr));
-                    if (simplifiedTarget == null) {
-                        simplifiedTarget = joinRel.getCluster().getRexBuilder().makeLiteral(false);
-                    }
-                    if (checkTarget(inferringFields, allExprs, tr)
-                            && checkTarget(inferringFields, allExprs, simplifiedTarget)) {
-                        inferredPredicates.add(simplifiedTarget);
-                        allExprs.add(simplifiedTarget);
-                    }
-                }
-            }
-        }
-
-        Iterable<Mapping> mappings(final RexNode predicate) {
-            final ImmutableBitSet fields =
-                    requireNonNull(
-                            exprFields.get(predicate),
-                            () -> "exprFields.get(predicate) is null for " + predicate);
-            if (fields.cardinality() == 0) {
-                return Collections.emptyList();
-            }
-            return () -> new ExprsItr(fields);
-        }
-
-        private static boolean checkTarget(
-                ImmutableBitSet inferringFields, Set<RexNode> allExprs, RexNode tr) {
-            return inferringFields.contains(RelOptUtil.InputFinder.bits(tr))
-                    && !allExprs.contains(tr)
-                    && !isAlwaysTrue(tr);
-        }
-
-        @SuppressWarnings("JdkObsolete")
-        private void markAsEquivalent(int p1, int p2) {
-            BitSet b = requireNonNull(equivalence.get(p1), () -> "equivalence.get(p1) for " + p1);
-            b.set(p2);
-
-            b = requireNonNull(equivalence.get(p2), () -> "equivalence.get(p2) for " + p2);
-            b.set(p1);
-        }
-
-        /** Find expressions of the form 'col_x = col_y'. */
-        class EquivalenceFinder extends RexVisitorImpl<Void> {
-            protected EquivalenceFinder() {
-                super(true);
-            }
-
-            @Override
-            public Void visitCall(RexCall call) {
-                if (call.getOperator().getKind() == SqlKind.EQUALS) {
-                    int lPos = pos(call.getOperands().get(0));
-                    int rPos = pos(call.getOperands().get(1));
-                    if (lPos != -1 && rPos != -1) {
-                        markAsEquivalent(lPos, rPos);
-                        equalityPredicates.add(call);
-                    }
-                }
-                return null;
-            }
-        }
-
-        /**
-         * Given an expression returns all the possible substitutions.
-         *
-         * <p>For example, for an expression 'a + b + c' and the following equivalences:
-         *
-         * <pre>
-         * a : {a, b}
-         * b : {a, b}
-         * c : {c, e}
-         * </pre>
-         *
-         * <p>The following Mappings will be returned:
-         *
-         * <pre>
-         * {a &rarr; a, b &rarr; a, c &rarr; c}
-         * {a &rarr; a, b &rarr; a, c &rarr; e}
-         * {a &rarr; a, b &rarr; b, c &rarr; c}
-         * {a &rarr; a, b &rarr; b, c &rarr; e}
-         * {a &rarr; b, b &rarr; a, c &rarr; c}
-         * {a &rarr; b, b &rarr; a, c &rarr; e}
-         * {a &rarr; b, b &rarr; b, c &rarr; c}
-         * {a &rarr; b, b &rarr; b, c &rarr; e}
-         * </pre>
-         *
-         * <p>which imply the following inferences:
-         *
-         * <pre>
-         * a + a + c
-         * a + a + e
-         * a + b + c
-         * a + b + e
-         * b + a + c
-         * b + a + e
-         * b + b + c
-         * b + b + e
-         * </pre>
-         */
-        class ExprsItr implements Iterator<Mapping> {
-            final int[] columns;
-            final BitSet[] columnSets;
-            final int[] iterationIdx;
-            @Nullable Mapping nextMapping;
-            boolean firstCall;
-
-            @SuppressWarnings("JdkObsolete")
-            ExprsItr(ImmutableBitSet fields) {
-                nextMapping = null;
-                columns = new int[fields.cardinality()];
-                columnSets = new BitSet[fields.cardinality()];
-                iterationIdx = new int[fields.cardinality()];
-                for (int j = 0, i = fields.nextSetBit(0);
-                        i >= 0;
-                        i = fields.nextSetBit(i + 1), j++) {
-                    columns[j] = i;
-                    int fieldIndex = i;
-                    columnSets[j] =
-                            requireNonNull(
-                                    equivalence.get(i),
-                                    () ->
-                                            "equivalence.get(i) is null for "
-                                                    + fieldIndex
-                                                    + ", "
-                                                    + equivalence);
-                    iterationIdx[j] = 0;
-                }
-                firstCall = true;
-            }
-
-            @Override
-            public boolean hasNext() {
-                if (firstCall) {
-                    initializeMapping();
-                    firstCall = false;
-                } else {
-                    computeNextMapping(iterationIdx.length - 1);
-                }
-                return nextMapping != null;
-            }
-
-            @Override
-            public Mapping next() {
-                if (nextMapping == null) {
-                    throw new NoSuchElementException();
-                }
-                return nextMapping;
-            }
-
-            @Override
-            public void remove() {
-                throw new UnsupportedOperationException();
-            }
-
-            private void computeNextMapping(int level) {
-                int t = columnSets[level].nextSetBit(iterationIdx[level]);
-                if (t < 0) {
-                    if (level == 0) {
-                        nextMapping = null;
-                    } else {
-                        int tmp = columnSets[level].nextSetBit(0);
-                        requireNonNull(nextMapping, "nextMapping").set(columns[level], tmp);
-                        iterationIdx[level] = tmp + 1;
-                        computeNextMapping(level - 1);
-                    }
-                } else {
-                    requireNonNull(nextMapping, "nextMapping").set(columns[level], t);
-                    iterationIdx[level] = t + 1;
-                }
-            }
-
-            private void initializeMapping() {
-                nextMapping =
-                        Mappings.create(
-                                MappingType.PARTIAL_FUNCTION,
-                                nSysFields + nFieldsLeft + nFieldsRight,
-                                nSysFields + nFieldsLeft + nFieldsRight);
-                for (int i = 0; i < columnSets.length; i++) {
-                    BitSet c = columnSets[i];
-                    int t = c.nextSetBit(iterationIdx[i]);
-                    if (t < 0) {
-                        nextMapping = null;
-                        return;
-                    }
-                    nextMapping.set(columns[i], t);
-                    iterationIdx[i] = t + 1;
-                }
-            }
-        }
-
-        private static int pos(RexNode expr) {
-            if (expr instanceof RexInputRef) {
-                return ((RexInputRef) expr).getIndex();
-            }
-            return -1;
-        }
-
-        private static boolean isAlwaysTrue(RexNode predicate) {
-            if (predicate instanceof RexCall) {
-                RexCall c = (RexCall) predicate;
-                if (c.getOperator().getKind() == SqlKind.EQUALS) {
-                    int lPos = pos(c.getOperands().get(0));
-                    int rPos = pos(c.getOperands().get(1));
-                    return lPos != -1 && lPos == rPos;
-                }
-            }
-            return predicate.isAlwaysTrue();
-        }
-    }
-}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
index bbf148401773e..7363bb119f867 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
@@ -46,10 +46,10 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import static java.util.Objects.requireNonNull;
 import static org.apache.calcite.util.Util.last;
 
 /**
@@ -65,7 +65,7 @@ public class SubQueryRemoveRule extends RelRule<SubQueryRemoveRule.Config>
     /** Creates a SubQueryRemoveRule. */
     protected SubQueryRemoveRule(Config config) {
         super(config);
-        Objects.requireNonNull(config.matchHandler());
+        requireNonNull(config.matchHandler());
     }
 
     @Override
@@ -849,8 +849,7 @@ private static List<RexNode> fields(RelBuilder builder, int fieldCount) {
     private static void matchProject(SubQueryRemoveRule rule, RelOptRuleCall call) {
         final Project project = call.rel(0);
         final RelBuilder builder = call.builder();
-        final RexSubQuery e = RexUtil.SubQueryFinder.find(project.getProjects());
-        assert e != null;
+        final RexSubQuery e = requireNonNull(RexUtil.SubQueryFinder.find(project.getProjects()));
         final RelOptUtil.Logic logic =
                 LogicVisitor.find(RelOptUtil.Logic.TRUE_FALSE_UNKNOWN, project.getProjects(), e);
         builder.push(project.getInput());
@@ -906,8 +905,7 @@ private static void matchFilter(SubQueryRemoveRule rule, RelOptRuleCall call) {
     private static void matchJoin(SubQueryRemoveRule rule, RelOptRuleCall call) {
         final Join join = call.rel(0);
         final RelBuilder builder = call.builder();
-        final RexSubQuery e = RexUtil.SubQueryFinder.find(join.getCondition());
-        assert e != null;
+        final RexSubQuery e = requireNonNull(RexUtil.SubQueryFinder.find(join.getCondition()));
         final RelOptUtil.Logic logic =
                 LogicVisitor.find(RelOptUtil.Logic.TRUE, ImmutableList.of(join.getCondition()), e);
         builder.push(join.getLeft());
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
index 464cb1eb6dd82..9b395adec1f18 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
@@ -72,7 +72,6 @@ public abstract class RelDataTypeFactoryImpl implements RelDataTypeFactory {
                     .build(CacheLoader.from(RelDataTypeFactoryImpl::keyToType));
 
     /** Global cache for RelDataType. */
-    @SuppressWarnings("BetaApi")
     private static final Interner<RelDataType> DATATYPE_CACHE = Interners.newWeakInterner();
 
     private static RelDataType keyToType(Key key) {
@@ -132,11 +131,10 @@ public RelDataType createJavaType(Class clazz) {
         return canonize(javaType);
     }
 
-    // implement RelDataTypeFactory
     @Override
     public RelDataType createJoinType(RelDataType... types) {
-        assert types != null;
-        assert types.length >= 1;
+        requireNonNull(types, "types");
+        checkArgument(types.length >= 1);
         final List<RelDataType> flattenedTypes = new ArrayList<>();
         getTypeList(ImmutableList.copyOf(types), flattenedTypes);
         return canonize(new RelCrossType(flattenedTypes, getFieldList(flattenedTypes)));
@@ -209,7 +207,7 @@ private RelDataType createStructType(
             List<RelDataType> types, SqlTypeMappingRule mappingRule) {
         requireNonNull(types, "types");
         requireNonNull(mappingRule, "mappingRule");
-        checkArgument(types.size() >= 1, "types.size >= 1");
+        checkArgument(!types.isEmpty(), "!types.isEmpty");
         RelDataType type0 = types.get(0);
         if (type0.isStruct()) {
             return leastRestrictiveStructuredType(types);
@@ -443,7 +441,6 @@ public int size() {
      *
      * @throws NullPointerException if type is null
      */
-    @SuppressWarnings("BetaApi")
     protected RelDataType canonize(final RelDataType type) {
         return DATATYPE_CACHE.intern(type);
     }
@@ -577,8 +574,7 @@ public RelDataType decimalOf(RelDataType type) {
     /** Create decimal type equivalent with the given {@code type} while sans nullability. */
     private RelDataType decimalOf2(RelDataType type) {
         assert SqlTypeUtil.isNumeric(type) || SqlTypeUtil.isNull(type);
-        SqlTypeName typeName = type.getSqlTypeName();
-        assert typeName != null;
+        final SqlTypeName typeName = requireNonNull(type.getSqlTypeName());
         switch (typeName) {
             case DECIMAL:
                 // Fix the precision when the type is JavaType.
@@ -630,8 +626,8 @@ public FieldInfoBuilder builder() {
     public class JavaType extends RelDataTypeImpl {
         private final Class clazz;
         private final boolean nullable;
-        private @Nullable SqlCollation collation;
-        private @Nullable Charset charset;
+        private final @Nullable SqlCollation collation;
+        private final @Nullable Charset charset;
 
         public JavaType(Class clazz) {
             this(clazz, !clazz.isPrimitive());
@@ -650,7 +646,8 @@ public JavaType(
             super(fieldsOf(clazz));
             this.clazz = clazz;
             this.nullable = nullable;
-            assert (charset != null) == SqlTypeUtil.inCharFamily(this) : "Need to be a chartype";
+            checkArgument(
+                    (charset != null) == SqlTypeUtil.inCharFamily(this), "Need to be a chartype");
             this.charset = charset;
             this.collation = collation;
             computeDigest();
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexBuilder.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexBuilder.java
index e6e34927cabca..d1d5a3c0cd1de 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexBuilder.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexBuilder.java
@@ -42,6 +42,7 @@
 import org.apache.calcite.sql.fun.SqlCountAggFunction;
 import org.apache.calcite.sql.fun.SqlLibraryOperators;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.type.ArraySqlType;
 import org.apache.calcite.sql.type.MapSqlType;
 import org.apache.calcite.sql.type.MultisetSqlType;
@@ -238,28 +239,60 @@ private RexNode makeFieldAccessInternal(RexNode expr, final RelDataTypeField fie
 
     /** Creates a call with a list of arguments and a predetermined type. */
     public RexNode makeCall(RelDataType returnType, SqlOperator op, List<RexNode> exprs) {
-        return new RexCall(returnType, op, exprs);
+        return makeCall(SqlParserPos.ZERO, returnType, op, exprs);
+    }
+
+    /**
+     * Creates a call with a list of arguments and a predetermined type.
+     *
+     * @param pos should be different from ZERO if the call can fail at runtime.
+     */
+    public RexNode makeCall(
+            SqlParserPos pos, RelDataType returnType, SqlOperator op, List<RexNode> exprs) {
+        return new RexCall(pos, returnType, op, exprs);
     }
 
     /**
      * Creates a call with an array of arguments.
      *
-     * <p>If you already know the return type of the call, then {@link
-     * #makeCall(org.apache.calcite.rel.type.RelDataType, org.apache.calcite.sql.SqlOperator,
-     * java.util.List)} is preferred.
+     * <p>If you already know the return type of the call, then {@link #makeCall(SqlParserPos,
+     * RelDataType, SqlOperator, List)} is preferred.
      */
     public RexNode makeCall(SqlOperator op, List<? extends RexNode> exprs) {
+        return makeCall(SqlParserPos.ZERO, op, exprs);
+    }
+
+    /**
+     * Creates a call with an array of arguments.
+     *
+     * @param pos should be different from ZERO if the call can fail at runtime.
+     *     <p>If you already know the return type of the call, then {@link #makeCall(SqlParserPos,
+     *     RelDataType, SqlOperator, List)} is preferred.
+     */
+    public RexNode makeCall(SqlParserPos pos, SqlOperator op, List<? extends RexNode> exprs) {
         final RelDataType type = deriveReturnType(op, exprs);
-        return new RexCall(type, op, exprs);
+        return new RexCall(pos, type, op, exprs);
     }
 
     /**
      * Creates a call with a list of arguments.
      *
-     * <p>Equivalent to <code>makeCall(op, exprList.toArray(new RexNode[exprList.size()]))</code>.
+     * <p>Equivalent to <code>makeCall(ZERO, op, exprList.toArray(new RexNode[exprList.size()]))
+     * </code>.
      */
     public final RexNode makeCall(SqlOperator op, RexNode... exprs) {
-        return makeCall(op, ImmutableList.copyOf(exprs));
+        return makeCall(SqlParserPos.ZERO, op, exprs);
+    }
+
+    /**
+     * Creates a call with a list of arguments.
+     *
+     * @param pos should be different from ZERO if the call can fail at runtime.
+     *     <p>Equivalent to <code>makeCall(pos, op, exprList.toArray(new RexNode[exprList.size()]))
+     *     </code>.
+     */
+    public final RexNode makeCall(SqlParserPos pos, SqlOperator op, RexNode... exprs) {
+        return makeCall(pos, op, ImmutableList.copyOf(exprs));
     }
 
     /**
@@ -384,9 +417,40 @@ public RexNode makeOver(
             boolean nullWhenCountZero,
             boolean distinct,
             boolean ignoreNulls) {
-        final RexWindow window = makeWindow(partitionKeys, orderKeys, lowerBound, upperBound, rows);
-        final RexOver over = new RexOver(type, operator, exprs, window, distinct, ignoreNulls);
-        RexNode result = over;
+        return makeOver(
+                type,
+                operator,
+                exprs,
+                partitionKeys,
+                orderKeys,
+                lowerBound,
+                upperBound,
+                RexWindowExclusion.EXCLUDE_NO_OTHER,
+                rows,
+                allowPartial,
+                nullWhenCountZero,
+                distinct,
+                ignoreNulls);
+    }
+
+    /** Creates a call to a windowed agg. */
+    public RexNode makeOver(
+            RelDataType type,
+            SqlAggFunction operator,
+            List<RexNode> exprs,
+            List<RexNode> partitionKeys,
+            ImmutableList<RexFieldCollation> orderKeys,
+            RexWindowBound lowerBound,
+            RexWindowBound upperBound,
+            RexWindowExclusion exclude,
+            boolean rows,
+            boolean allowPartial,
+            boolean nullWhenCountZero,
+            boolean distinct,
+            boolean ignoreNulls) {
+        final RexWindow window =
+                makeWindow(partitionKeys, orderKeys, lowerBound, upperBound, rows, exclude);
+        RexNode result = new RexOver(type, operator, exprs, window, distinct, ignoreNulls);
 
         // This should be correct but need time to go over test results.
         // Also want to look at combing with section below.
@@ -459,17 +523,44 @@ public RexWindow makeWindow(
             RexWindowBound lowerBound,
             RexWindowBound upperBound,
             boolean rows) {
-        if (lowerBound.isUnbounded()
-                && lowerBound.isPreceding()
-                && upperBound.isUnbounded()
-                && upperBound.isFollowing()) {
+        return makeWindow(
+                partitionKeys,
+                orderKeys,
+                lowerBound,
+                upperBound,
+                rows,
+                RexWindowExclusion.EXCLUDE_NO_OTHER);
+    }
+
+    /**
+     * Creates a window specification.
+     *
+     * @param partitionKeys Partition keys
+     * @param orderKeys Order keys
+     * @param lowerBound Lower bound
+     * @param upperBound Upper bound
+     * @param rows Whether physical. True if row-based, false if range-based
+     * @return window specification
+     */
+    public RexWindow makeWindow(
+            List<RexNode> partitionKeys,
+            ImmutableList<RexFieldCollation> orderKeys,
+            RexWindowBound lowerBound,
+            RexWindowBound upperBound,
+            boolean rows,
+            RexWindowExclusion exclude) {
+        if (orderKeys.isEmpty() && !rows) {
+            lowerBound = RexWindowBounds.UNBOUNDED_PRECEDING;
+            upperBound = RexWindowBounds.UNBOUNDED_FOLLOWING;
+        }
+        if (lowerBound.isUnboundedPreceding() && upperBound.isUnboundedFollowing()) {
             // RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
             //   is equivalent to
             // ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
             //   but we prefer "RANGE"
             rows = false;
         }
-        return new RexWindow(partitionKeys, orderKeys, lowerBound, upperBound, rows);
+        return new RexWindow(partitionKeys, orderKeys, lowerBound, upperBound, rows, exclude);
     }
 
     /**
@@ -516,11 +607,46 @@ public RexNode makeCast(RelDataType type, RexNode exp) {
         return makeCast(type, exp, false, false, constantNull);
     }
 
+    /**
+     * Creates a call to the CAST operator.
+     *
+     * @param pos Parser position of the cast.
+     * @param type Type to cast to
+     * @param exp Expression being cast
+     * @return Call to CAST operator
+     */
+    public RexNode makeCast(SqlParserPos pos, RelDataType type, RexNode exp) {
+        return makeCast(pos, type, exp, false, false, constantNull);
+    }
+
     @Deprecated // to be removed before 2.0
     public RexNode makeCast(RelDataType type, RexNode exp, boolean matchNullability) {
         return makeCast(type, exp, matchNullability, false, constantNull);
     }
 
+    /**
+     * Creates a call to the CAST operator, expanding if possible, and optionally also preserving
+     * nullability, and optionally in safe mode.
+     *
+     * <p>Tries to expand the cast, and therefore the result may be something other than a {@link
+     * RexCall} to the CAST operator, such as a {@link RexLiteral}.
+     *
+     * @param pos Parser position
+     * @param type Type to cast to
+     * @param exp Expression being cast
+     * @param matchNullability Whether to ensure the result has the same nullability as {@code type}
+     * @param safe Whether to return NULL if cast fails
+     * @return Call to CAST operator
+     */
+    public RexNode makeCast(
+            SqlParserPos pos,
+            RelDataType type,
+            RexNode exp,
+            boolean matchNullability,
+            boolean safe) {
+        return makeCast(pos, type, exp, matchNullability, safe, constantNull);
+    }
+
     /**
      * Creates a call to the CAST operator, expanding if possible, and optionally also preserving
      * nullability, and optionally in safe mode.
@@ -558,6 +684,31 @@ public RexNode makeCast(
             boolean matchNullability,
             boolean safe,
             RexLiteral format) {
+        return makeCast(SqlParserPos.ZERO, type, exp, matchNullability, safe, format);
+    }
+
+    /**
+     * Creates a call to the CAST operator, expanding if possible, and optionally also preserving
+     * nullability, and optionally in safe mode.
+     *
+     * <p>Tries to expand the cast, and therefore the result may be something other than a {@link
+     * RexCall} to the CAST operator, such as a {@link RexLiteral}.
+     *
+     * @param pos Parser position
+     * @param type Type to cast to
+     * @param exp Expression being cast
+     * @param matchNullability Whether to ensure the result has the same nullability as {@code type}
+     * @param safe Whether to return NULL if cast fails
+     * @param format Type Format to cast into
+     * @return Call to CAST operator
+     */
+    public RexNode makeCast(
+            SqlParserPos pos,
+            RelDataType type,
+            RexNode exp,
+            boolean matchNullability,
+            boolean safe,
+            RexLiteral format) {
         final SqlTypeName sqlType = type.getSqlTypeName();
         if (exp instanceof RexLiteral) {
             RexLiteral literal = (RexLiteral) exp;
@@ -622,19 +773,19 @@ public RexNode makeCast(
                 }
                 final RexLiteral literal2 = makeLiteral(value, type, typeName);
                 if (type.isNullable() && !literal2.getType().isNullable() && matchNullability) {
-                    return makeAbstractCast(type, literal2, safe, format);
+                    return makeAbstractCast(pos, type, literal2, safe, format);
                 }
                 return literal2;
             }
         } else if (SqlTypeUtil.isExactNumeric(type) && SqlTypeUtil.isInterval(exp.getType())) {
-            return makeCastIntervalToExact(type, exp);
+            return makeCastIntervalToExact(pos, type, exp);
         } else if (sqlType == SqlTypeName.BOOLEAN && SqlTypeUtil.isExactNumeric(exp.getType())) {
             return makeCastExactToBoolean(type, exp);
         } else if (exp.getType().getSqlTypeName() == SqlTypeName.BOOLEAN
                 && SqlTypeUtil.isExactNumeric(type)) {
             return makeCastBooleanToExact(type, exp);
         }
-        return makeAbstractCast(type, exp, safe, format);
+        return makeAbstractCast(pos, type, exp, safe, format);
     }
 
     /**
@@ -650,16 +801,25 @@ protected static TimeUnit baseUnit(SqlTypeName unit) {
     }
 
     boolean canRemoveCastFromLiteral(
-            RelDataType toType, @Nullable Comparable value, SqlTypeName fromTypeName) {
+            RelDataType toType,
+            @SuppressWarnings("rawtypes") @Nullable Comparable value,
+            SqlTypeName fromTypeName) {
         if (value == null) {
             return true;
         }
         final SqlTypeName sqlType = toType.getSqlTypeName();
+        if (sqlType == SqlTypeName.MEASURE) {
+            return false;
+        }
         if (!RexLiteral.valueMatchesType(value, sqlType, false)) {
             return false;
         }
         if (toType.getSqlTypeName() != fromTypeName
-                && SqlTypeFamily.DATETIME.getTypeNames().contains(fromTypeName)) {
+                && (SqlTypeFamily.DATETIME.getTypeNames().contains(fromTypeName)
+                        || SqlTypeFamily.INTERVAL_DAY_TIME.getTypeNames().contains(fromTypeName)
+                        || SqlTypeFamily.INTERVAL_YEAR_MONTH
+                                .getTypeNames()
+                                .contains(fromTypeName))) {
             return false;
         }
         if (value instanceof NlsString) {
@@ -685,31 +845,32 @@ boolean canRemoveCastFromLiteral(
             }
         }
 
-        if (toType.getSqlTypeName() == SqlTypeName.DECIMAL) {
+        if (toType.getSqlTypeName() == SqlTypeName.DECIMAL
+                && fromTypeName.getFamily() == SqlTypeFamily.NUMERIC) {
             final BigDecimal decimalValue = (BigDecimal) value;
-            return SqlTypeUtil.isValidDecimalValue(decimalValue, toType);
+            return SqlTypeUtil.canBeRepresentedExactly(decimalValue, toType);
         }
 
         if (SqlTypeName.INT_TYPES.contains(sqlType)) {
             final BigDecimal decimalValue = (BigDecimal) value;
-            final int s = decimalValue.scale();
-            if (s != 0) {
+            try {
+                // Will throw ArithmeticException if the value cannot be represented using a 'long'
+                long l = decimalValue.longValueExact();
+                switch (sqlType) {
+                    case TINYINT:
+                        return l >= Byte.MIN_VALUE && l <= Byte.MAX_VALUE;
+                    case SMALLINT:
+                        return l >= Short.MIN_VALUE && l <= Short.MAX_VALUE;
+                    case INTEGER:
+                        return l >= Integer.MIN_VALUE && l <= Integer.MAX_VALUE;
+                    case BIGINT:
+                    default:
+                        return true;
+                }
+            } catch (ArithmeticException ex) {
                 return false;
             }
-            long l = decimalValue.longValue();
-            switch (sqlType) {
-                case TINYINT:
-                    return l >= Byte.MIN_VALUE && l <= Byte.MAX_VALUE;
-                case SMALLINT:
-                    return l >= Short.MIN_VALUE && l <= Short.MAX_VALUE;
-                case INTEGER:
-                    return l >= Integer.MIN_VALUE && l <= Integer.MAX_VALUE;
-                case BIGINT:
-                default:
-                    return true;
-            }
         }
-
         return true;
     }
 
@@ -739,16 +900,21 @@ private RexNode makeCastBooleanToExact(RelDataType toType, RexNode exp) {
                         makeNullLiteral(toType)));
     }
 
-    private RexNode makeCastIntervalToExact(RelDataType toType, RexNode exp) {
+    private RexNode makeCastIntervalToExact(SqlParserPos pos, RelDataType toType, RexNode exp) {
         final TimeUnit endUnit = exp.getType().getSqlTypeName().getEndUnit();
         final TimeUnit baseUnit = baseUnit(exp.getType().getSqlTypeName());
         final BigDecimal multiplier = baseUnit.multiplier;
         final BigDecimal divider = endUnit.multiplier;
-        RexNode value = multiplyDivide(decodeIntervalOrDecimal(exp), multiplier, divider);
-        return ensureType(toType, value, false);
+        RexNode value = multiplyDivide(pos, decodeIntervalOrDecimal(pos, exp), multiplier, divider);
+        return ensureType(pos, toType, value, false);
     }
 
     public RexNode multiplyDivide(RexNode e, BigDecimal multiplier, BigDecimal divider) {
+        return multiplyDivide(SqlParserPos.ZERO, e, multiplier, divider);
+    }
+
+    public RexNode multiplyDivide(
+            SqlParserPos pos, RexNode e, BigDecimal multiplier, BigDecimal divider) {
         assert multiplier.signum() > 0;
         assert divider.signum() > 0;
         switch (multiplier.compareTo(divider)) {
@@ -757,12 +923,14 @@ public RexNode multiplyDivide(RexNode e, BigDecimal multiplier, BigDecimal divid
             case 1:
                 // E.g. multiplyDivide(e, 1000, 10) ==> e * 100
                 return makeCall(
+                        pos,
                         SqlStdOperatorTable.MULTIPLY,
                         e,
                         makeExactLiteral(multiplier.divide(divider, RoundingMode.UNNECESSARY)));
             case -1:
                 // E.g. multiplyDivide(e, 10, 1000) ==> e / 100
                 return makeCall(
+                        pos,
                         SqlStdOperatorTable.DIVIDE_INTEGER,
                         e,
                         makeExactLiteral(divider.divide(multiplier, RoundingMode.UNNECESSARY)));
@@ -786,9 +954,14 @@ public RexNode multiplyDivide(RexNode e, BigDecimal multiplier, BigDecimal divid
      * @return the integer reinterpreted as an opaque decimal type
      */
     public RexNode encodeIntervalOrDecimal(RexNode value, RelDataType type, boolean checkOverflow) {
+        return encodeIntervalOrDecimal(SqlParserPos.ZERO, value, type, checkOverflow);
+    }
+
+    public RexNode encodeIntervalOrDecimal(
+            SqlParserPos pos, RexNode value, RelDataType type, boolean checkOverflow) {
         RelDataType bigintType = typeFactory.createSqlType(SqlTypeName.BIGINT);
-        RexNode cast = ensureType(bigintType, value, true);
-        return makeReinterpretCast(type, cast, makeLiteral(checkOverflow));
+        RexNode cast = ensureType(pos, bigintType, value, true);
+        return makeReinterpretCast(pos, type, cast, makeLiteral(checkOverflow));
     }
 
     /**
@@ -798,9 +971,14 @@ public RexNode encodeIntervalOrDecimal(RexNode value, RelDataType type, boolean
      * @return an integer representation of the decimal value
      */
     public RexNode decodeIntervalOrDecimal(RexNode node) {
+        return decodeIntervalOrDecimal(SqlParserPos.ZERO, node);
+    }
+
+    public RexNode decodeIntervalOrDecimal(SqlParserPos pos, RexNode node) {
         assert SqlTypeUtil.isDecimal(node.getType()) || SqlTypeUtil.isInterval(node.getType());
         RelDataType bigintType = typeFactory.createSqlType(SqlTypeName.BIGINT);
-        return makeReinterpretCast(matchNullability(bigintType, node), node, makeLiteral(false));
+        return makeReinterpretCast(
+                pos, matchNullability(bigintType, node), node, makeLiteral(false));
     }
 
     @Deprecated // to be removed before 2.0
@@ -817,9 +995,22 @@ public RexNode makeAbstractCast(RelDataType type, RexNode exp) {
      * @return Call to CAST operator
      */
     public RexNode makeAbstractCast(RelDataType type, RexNode exp, boolean safe) {
+        return makeAbstractCast(SqlParserPos.ZERO, type, exp, safe);
+    }
+
+    /**
+     * Creates a call to CAST or SAFE_CAST operator.
+     *
+     * @param pos Parser position.
+     * @param type Type to cast to
+     * @param exp Expression being cast
+     * @param safe Whether to return NULL if cast fails
+     * @return Call to CAST operator Casts can fail at runtime, so we expect position information.
+     */
+    public RexNode makeAbstractCast(SqlParserPos pos, RelDataType type, RexNode exp, boolean safe) {
         final SqlOperator operator =
                 safe ? SqlLibraryOperators.SAFE_CAST : SqlStdOperatorTable.CAST;
-        return new RexCall(type, operator, ImmutableList.of(exp));
+        return new RexCall(pos, type, operator, ImmutableList.of(exp));
     }
 
     /**
@@ -833,12 +1024,27 @@ public RexNode makeAbstractCast(RelDataType type, RexNode exp, boolean safe) {
      */
     public RexNode makeAbstractCast(
             RelDataType type, RexNode exp, boolean safe, RexLiteral format) {
+        return makeAbstractCast(SqlParserPos.ZERO, type, exp, safe, format);
+    }
+
+    /**
+     * Creates a call to CAST or SAFE_CAST operator with a FORMAT clause.
+     *
+     * @param pos Parser position
+     * @param type Type to cast to
+     * @param exp Expression being cast
+     * @param safe Whether to return NULL if cast fails
+     * @param format Conversion format for target type
+     * @return Call to CAST operator
+     */
+    public RexNode makeAbstractCast(
+            SqlParserPos pos, RelDataType type, RexNode exp, boolean safe, RexLiteral format) {
         final SqlOperator operator =
                 safe ? SqlLibraryOperators.SAFE_CAST : SqlStdOperatorTable.CAST;
         if (format.isNull()) {
-            return new RexCall(type, operator, ImmutableList.of(exp));
+            return new RexCall(pos, type, operator, ImmutableList.of(exp));
         }
-        return new RexCall(type, operator, ImmutableList.of(exp, format));
+        return new RexCall(pos, type, operator, ImmutableList.of(exp, format));
     }
 
     /**
@@ -850,23 +1056,56 @@ public RexNode makeAbstractCast(
      * @return a RexCall with two operands and a special return type
      */
     public RexNode makeReinterpretCast(RelDataType type, RexNode exp, RexNode checkOverflow) {
+        return makeReinterpretCast(SqlParserPos.ZERO, type, exp, checkOverflow);
+    }
+
+    /**
+     * Makes a reinterpret cast.
+     *
+     * @param pos parser position
+     * @param type type returned by the cast
+     * @param exp expression to be cast
+     * @param checkOverflow whether an overflow check is required
+     * @return a RexCall with two operands and a special return type
+     */
+    public RexNode makeReinterpretCast(
+            SqlParserPos pos, RelDataType type, RexNode exp, RexNode checkOverflow) {
         List<RexNode> args;
-        if ((checkOverflow != null) && checkOverflow.isAlwaysTrue()) {
+        if (checkOverflow.isAlwaysTrue()) {
             args = ImmutableList.of(exp, checkOverflow);
         } else {
             args = ImmutableList.of(exp);
         }
-        return new RexCall(type, SqlStdOperatorTable.REINTERPRET, args);
+        return new RexCall(pos, type, SqlStdOperatorTable.REINTERPRET, args);
     }
 
-    /** Makes a cast of a value to NOT NULL; no-op if the type already has NOT NULL. */
+    /**
+     * Makes a cast of an expression to nullable; returns the expression unchanged if its type is
+     * already nullable.
+     */
+    public RexNode makeNullable(RexNode exp) {
+        return makeNullable(exp, true);
+    }
+
+    /**
+     * Makes a cast of an expression to NOT NULL; returns the expression unchanged if its type
+     * already has NOT NULL.
+     */
     public RexNode makeNotNull(RexNode exp) {
+        return makeNullable(exp, false);
+    }
+
+    /**
+     * Makes a cast of an expression to the required nullability; returns the expression unchanged
+     * if its type already has the desired nullability.
+     */
+    public RexNode makeNullable(RexNode exp, boolean nullability) {
         final RelDataType type = exp.getType();
-        if (!type.isNullable()) {
+        if (type.isNullable() == nullability) {
             return exp;
         }
-        final RelDataType notNullType = typeFactory.createTypeWithNullability(type, false);
-        return makeAbstractCast(notNullType, exp, false);
+        final RelDataType type2 = typeFactory.createTypeWithNullability(type, nullability);
+        return makeAbstractCast(SqlParserPos.ZERO, type2, exp, false);
     }
 
     /**
@@ -952,8 +1191,10 @@ public RexLocalRef makeLocalRef(RelDataType type, int i) {
      * @param flag Flag value
      */
     public RexLiteral makeFlag(Enum flag) {
-        assert flag != null;
-        return makeLiteral(flag, typeFactory.createSqlType(SqlTypeName.SYMBOL), SqlTypeName.SYMBOL);
+        return makeLiteral(
+                requireNonNull(flag, "flag"),
+                typeFactory.createSqlType(SqlTypeName.SYMBOL),
+                SqlTypeName.SYMBOL);
     }
 
     /**
@@ -983,10 +1224,10 @@ protected RexLiteral makeLiteral(
                         || !Objects.equals(nlsString.getCollation(), type.getCollation())) {
                     assert type.getSqlTypeName() == SqlTypeName.CHAR
                             || type.getSqlTypeName() == SqlTypeName.VARCHAR;
-                    Charset charset = type.getCharset();
-                    assert charset != null : "type.getCharset() must not be null";
-                    assert type.getCollation() != null : "type.getCollation() must not be null";
-                    o = new NlsString(nlsString.getValue(), charset.name(), type.getCollation());
+                    Charset charset = requireNonNull(type.getCharset(), "type.getCharset()");
+                    final SqlCollation collation =
+                            requireNonNull(type.getCollation(), "type.getCollation()");
+                    o = new NlsString(nlsString.getValue(), charset.name(), collation);
                 }
                 break;
             case TIME:
@@ -1023,6 +1264,19 @@ protected RexLiteral makeLiteral(
                 }
                 o = ((TimestampWithTimeZoneString) o).round(p);
                 break;
+            case DECIMAL:
+                if (o != null && type.getScale() != RelDataType.SCALE_NOT_SPECIFIED) {
+                    assert o instanceof BigDecimal;
+                    o =
+                            ((BigDecimal) o)
+                                    .setScale(
+                                            type.getScale(),
+                                            typeFactory.getTypeSystem().roundingMode());
+                    if (type.getScale() < 0) {
+                        o = new BigDecimal(((BigDecimal) o).toPlainString());
+                    }
+                }
+                break;
             default:
                 break;
         }
@@ -1040,6 +1294,7 @@ public RexLiteral makeLiteral(boolean b) {
     }
 
     /** Creates a numeric literal. */
+    @SuppressWarnings("deprecation") // [CALCITE-6598]
     public RexLiteral makeExactLiteral(BigDecimal bd) {
         RelDataType relType;
         int scale = bd.scale();
@@ -1102,7 +1357,19 @@ public RexLiteral makeApproxLiteral(BigDecimal bd) {
      */
     public RexLiteral makeApproxLiteral(@Nullable BigDecimal bd, RelDataType type) {
         assert SqlTypeFamily.APPROXIMATE_NUMERIC.getTypeNames().contains(type.getSqlTypeName());
-        return makeLiteral(bd, type, SqlTypeName.DOUBLE);
+        return makeLiteral(bd != null ? bd.doubleValue() : null, type, SqlTypeName.DOUBLE);
+    }
+
+    /**
+     * Creates an approximate numeric literal (double or float) from a Double value.
+     *
+     * @param val literal value
+     * @param type approximate numeric type
+     * @return new literal
+     */
+    public RexLiteral makeApproxLiteral(Double val, RelDataType type) {
+        assert SqlTypeFamily.APPROXIMATE_NUMERIC.getTypeNames().contains(type.getSqlTypeName());
+        return makeLiteral(val, type, SqlTypeName.DOUBLE);
     }
 
     /** Creates a search argument literal. */
@@ -1112,8 +1379,7 @@ public RexLiteral makeSearchArgumentLiteral(Sarg s, RelDataType type) {
 
     /** Creates a character string literal. */
     public RexLiteral makeLiteral(String s) {
-        assert s != null;
-        return makePreciseStringLiteral(s);
+        return makePreciseStringLiteral(requireNonNull(s, "s"));
     }
 
     /**
@@ -1123,8 +1389,7 @@ public RexLiteral makeLiteral(String s) {
      * @return Character string literal
      */
     protected RexLiteral makePreciseStringLiteral(String s) {
-        assert s != null;
-        if (s.equals("")) {
+        if (s.isEmpty()) {
             return charEmpty;
         }
         return makeCharLiteral(new NlsString(s, null, null));
@@ -1155,6 +1420,23 @@ protected RexLiteral makePreciseStringLiteral(
      * @return a casted expression or the original expression
      */
     public RexNode ensureType(RelDataType type, RexNode node, boolean matchNullability) {
+        return ensureType(SqlParserPos.ZERO, type, node, matchNullability);
+    }
+
+    /**
+     * Ensures expression is interpreted as a specified type. The returned expression may be wrapped
+     * with a cast.
+     *
+     * @param pos parser position
+     * @param type desired type
+     * @param node expression
+     * @param matchNullability whether to correct nullability of specified type to match the
+     *     expression; this usually should be true, except for explicit casts which can override
+     *     default nullability
+     * @return a casted expression or the original expression
+     */
+    public RexNode ensureType(
+            SqlParserPos pos, RelDataType type, RexNode node, boolean matchNullability) {
         RelDataType targetType = type;
         if (matchNullability) {
             targetType = matchNullability(type, node);
@@ -1166,7 +1448,7 @@ public RexNode ensureType(RelDataType type, RexNode node, boolean matchNullabili
         }
 
         if (!node.getType().equals(targetType)) {
-            return makeCast(targetType, node);
+            return makeCast(pos, targetType, node);
         }
         return node;
     }
@@ -1187,7 +1469,6 @@ public RelDataType matchNullability(RelDataType type, RexNode value) {
      * <p>If the string's charset and collation are not set, uses the system defaults.
      */
     public RexLiteral makeCharLiteral(NlsString str) {
-        assert str != null;
         RelDataType type = SqlUtil.createNlsStringType(typeFactory, str);
         return makeLiteral(str, type, SqlTypeName.CHAR);
     }
@@ -1395,7 +1676,6 @@ private static boolean areAssignable(RexNode arg, List<? extends RexNode> bounds
      * literal, {@code SEARCH(arg, SARG([lower..upper])}; otherwise creates a disjunction, {@code
      * arg >= lower AND arg <= upper}.
      */
-    @SuppressWarnings("BetaApi")
     public RexNode makeBetween(RexNode arg, RexNode lower, RexNode upper) {
         final Comparable lowerValue = toComparable(Comparable.class, lower);
         final Comparable upperValue = toComparable(Comparable.class, upper);
@@ -1421,7 +1701,6 @@ && areAssignable(arg, Arrays.asList(lower, upper))) {
     }
 
     /** Converts a list of expressions to a search argument, or returns null if not possible. */
-    @SuppressWarnings({"BetaApi", "UnstableApiUsage"})
     private static <C extends Comparable<C>> @Nullable Sarg<C> toSarg(
             Class<C> clazz, List<? extends RexNode> ranges, RexUnknownAs unknownAs) {
         if (ranges.isEmpty()) {
@@ -1632,7 +1911,10 @@ public RexNode makeLiteral(
             case FLOAT:
             case REAL:
             case DOUBLE:
-                return makeApproxLiteral((BigDecimal) value, type);
+                if (value instanceof Double) {
+                    return makeApproxLiteral((Double) value, type);
+                }
+                return makeApproxLiteral(((BigDecimal) value).doubleValue(), type);
             case BOOLEAN:
                 return (Boolean) value ? booleanTrue : booleanFalse;
             case TIME:
@@ -1782,22 +2064,31 @@ public RexNode makeLambdaCall(RexNode expr, List<RexLambdaRef> parameters) {
                 if (o instanceof BigDecimal) {
                     return o;
                 }
+                // Float values are stored as Doubles
+                if (o instanceof Float) {
+                    return ((Float) o).doubleValue();
+                }
+                if (o instanceof Double) {
+                    return o;
+                }
                 return new BigDecimal(((Number) o).doubleValue(), MathContext.DECIMAL32)
                         .stripTrailingZeros();
             case FLOAT:
             case DOUBLE:
-                if (o instanceof BigDecimal) {
+                if (o instanceof Double) {
                     return o;
                 }
-                return new BigDecimal(((Number) o).doubleValue(), MathContext.DECIMAL64)
-                        .stripTrailingZeros();
+                return ((Number) o).doubleValue();
             case CHAR:
             case VARCHAR:
                 if (o instanceof NlsString) {
                     return o;
                 }
-                assert type.getCharset() != null : type + ".getCharset() must not be null";
-                return new NlsString((String) o, type.getCharset().name(), type.getCollation());
+                final Charset charset = type.getCharset();
+                if (charset == null) {
+                    throw new AssertionError(type + ".getCharset() must not be null");
+                }
+                return new NlsString((String) o, charset.name(), type.getCollation());
             case TIME:
                 if (o instanceof TimeString) {
                     return o;
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexChecker.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexChecker.java
index 9d7506c20342c..572f1192f6587 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexChecker.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexChecker.java
@@ -34,23 +34,29 @@
  * <p>There are two modes of operation:
  *
  * <ul>
- *   <li>Use<code>fail=true</code> to throw an {@link AssertionError} as soon as an invalid node is
- *       detected:
+ *   <li>{@link Litmus#THROW} causes the checker to throw an {@link AssertionError} as soon as an
+ *       invalid node is detected. Note: This mode requires that assertions are enabled.
  *       <blockquote>
- *       <code>RexNode node;<br>
- * RelDataType rowType;<br>
- * assert new RexChecker(rowType, true).isValid(node);</code>
+ *       <pre>
+ * // Example usage of Litmus.THROW
+ * RexNode node;
+ * RelDataType rowType;
+ * RexChecker checker = new RexChecker(rowType, Litmus.THROW);
+ * node.accept(checker); // Will throw an AssertionError if node is invalid
+ * </pre>
  *       </blockquote>
- *       <p>This mode requires that assertions are enabled.
- *   <li>Use <code>fail=false</code> to test for validity without throwing an error.
+ *   <li>{@link Litmus#IGNORE} tests validity without throwing an error.
  *       <blockquote>
- *       <code>RexNode node;<br>
- * RelDataType rowType;<br>
- * RexChecker checker = new RexChecker(rowType, false);<br>
- * node.accept(checker);<br>
- * if (!checker.valid) {<br>
- * &nbsp;&nbsp;&nbsp;...<br>
- * }</code>
+ *       <pre>
+ * // Example usage of Litmus.IGNORE
+ * RexNode node;
+ * RelDataType rowType;
+ * RexChecker checker = new RexChecker(rowType, Litmus.IGNORE);
+ * node.accept(checker);
+ * if (!checker.isValid()) {
+ *     // Handle invalid node
+ * }
+ * </pre>
  *       </blockquote>
  * </ul>
  *
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexShuttle.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexShuttle.java
index 5a20c53c23927..1c753da9de3d0 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexShuttle.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexShuttle.java
@@ -17,12 +17,11 @@
 package org.apache.calcite.rex;
 
 import com.google.common.collect.ImmutableList;
+import org.apache.calcite.sql.SqlAggFunction;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static java.util.Objects.requireNonNull;
-
 /**
  * Passes over a row-expression, calling a handler method for each node, appropriate to the type of
  * the node.
@@ -40,8 +39,9 @@ public class RexShuttle implements RexVisitor<RexNode> {
     public RexNode visitOver(RexOver over) {
         boolean[] update = {false};
         List<RexNode> clonedOperands = visitList(over.operands, update);
+        SqlAggFunction overAggregator = visitOverAggFunction(over.getAggOperator());
         RexWindow window = visitWindow(over.getWindow());
-        if (update[0] || (window != over.getWindow())) {
+        if (update[0] || (window != over.getWindow()) || overAggregator != over.getAggOperator()) {
             // REVIEW jvs 8-Mar-2005:  This doesn't take into account
             // the fact that a rewrite may have changed the result type.
             // To do that, we would need to take a RexBuilder and
@@ -49,7 +49,7 @@ public RexNode visitOver(RexOver over) {
             // the type is embedded in the original call.
             return new RexOver(
                     over.getType(),
-                    over.getAggOperator(),
+                    overAggregator,
                     clonedOperands,
                     window,
                     over.isDistinct(),
@@ -59,31 +59,36 @@ public RexNode visitOver(RexOver over) {
         }
     }
 
+    public SqlAggFunction visitOverAggFunction(SqlAggFunction op) {
+        return op;
+    }
+
     public RexWindow visitWindow(RexWindow window) {
         boolean[] update = {false};
         List<RexFieldCollation> clonedOrderKeys = visitFieldCollations(window.orderKeys, update);
         List<RexNode> clonedPartitionKeys = visitList(window.partitionKeys, update);
         final RexWindowBound lowerBound = window.getLowerBound().accept(this);
         final RexWindowBound upperBound = window.getUpperBound().accept(this);
-        if (lowerBound == null
-                || upperBound == null
-                || !update[0]
-                        && lowerBound == window.getLowerBound()
-                        && upperBound == window.getUpperBound()) {
+        if (!update[0]
+                && lowerBound == window.getLowerBound()
+                && upperBound == window.getUpperBound()) {
             return window;
         }
         boolean rows = window.isRows();
-        if (lowerBound.isUnbounded()
-                && lowerBound.isPreceding()
-                && upperBound.isUnbounded()
-                && upperBound.isFollowing()) {
+        if (lowerBound.isUnboundedPreceding() && upperBound.isUnboundedFollowing()) {
             // RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
             //   is equivalent to
             // ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
             //   but we prefer "RANGE"
             rows = false;
         }
-        return new RexWindow(clonedPartitionKeys, clonedOrderKeys, lowerBound, upperBound, rows);
+        return new RexWindow(
+                clonedPartitionKeys,
+                clonedOrderKeys,
+                lowerBound,
+                upperBound,
+                rows,
+                window.getExclude());
     }
 
     @Override
@@ -176,7 +181,7 @@ protected List<RexFieldCollation> visitFieldCollations(
             RexNode clonedOperand = collation.left.accept(this);
             if ((clonedOperand != collation.left) && (update != null)) {
                 update[0] = true;
-                collation = new RexFieldCollation(clonedOperand, requireNonNull(collation.right));
+                collation = new RexFieldCollation(clonedOperand, collation.right);
             }
             clonedOperands.add(collation);
         }
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
index bddc6a15239ad..2d70616ca966e 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
@@ -30,6 +30,7 @@
 import org.apache.calcite.rel.RelCollation;
 import org.apache.calcite.rel.RelCollations;
 import org.apache.calcite.rel.RelFieldCollation;
+import org.apache.calcite.rel.core.Calc;
 import org.apache.calcite.rel.core.Filter;
 import org.apache.calcite.rel.core.Join;
 import org.apache.calcite.rel.core.Project;
@@ -89,6 +90,9 @@ public class RexUtil {
     /** Executor for a bit of constant reduction. The user can pass in another executor. */
     public static final RexExecutor EXECUTOR = new RexExecutorImpl(DataContexts.EMPTY);
 
+    /** Finds calls to the {@link org.apache.calcite.sql.fun.SqlInternalOperators#M2V} function. */
+    public static final RexFinder M2V_FINDER = find(SqlKind.M2V);
+
     private RexUtil() {}
 
     // ~ Methods ----------------------------------------------------------------
@@ -180,10 +184,8 @@ public static boolean isNullLiteral(RexNode node, boolean allowCast) {
         if (allowCast) {
             if (node.isA(SqlKind.CAST)) {
                 RexCall call = (RexCall) node;
-                if (isNullLiteral(call.operands.get(0), false)) {
-                    // node is "CAST(NULL as type)"
-                    return true;
-                }
+                // node is "CAST(NULL as type)"
+                return isNullLiteral(call.operands.get(0), false);
             }
         }
         return false;
@@ -233,17 +235,15 @@ public static boolean isSymbolLiteral(RexNode expr) {
      * @return Whether the node is a literal
      */
     public static boolean isLiteral(RexNode node, boolean allowCast) {
-        assert node != null;
+        requireNonNull(node, "node");
         if (node.isA(SqlKind.LITERAL)) {
             return true;
         }
         if (allowCast) {
             if (node.isA(SqlKind.CAST)) {
                 RexCall call = (RexCall) node;
-                if (isLiteral(call.operands.get(0), false)) {
-                    // node is "CAST(literal as type)"
-                    return true;
-                }
+                // node is "CAST(literal as type)"
+                return isLiteral(call.operands.get(0), false);
             }
         }
         return false;
@@ -272,7 +272,7 @@ public static boolean allLiterals(List<RexNode> expressionOperands) {
      * @return Whether the node is a reference or access
      */
     public static boolean isReferenceOrAccess(RexNode node, boolean allowCast) {
-        assert node != null;
+        requireNonNull(node, "node");
         if (node instanceof RexInputRef || node instanceof RexFieldAccess) {
             return true;
         }
@@ -627,7 +627,6 @@ public static RexShuttle searchShuttle(
         return new SearchExpandingShuttle(program, rexBuilder, maxComplexity);
     }
 
-    @SuppressWarnings("BetaApi")
     public static <C extends Comparable<C>> RexNode sargRef(
             RexBuilder rexBuilder,
             RexNode ref,
@@ -1381,7 +1380,7 @@ public static RexNode composeDisjunction(
 
     /** Flattens a list of OR nodes. */
     public static ImmutableList<RexNode> flattenOr(Iterable<? extends RexNode> nodes) {
-        if (nodes instanceof Collection && ((Collection) nodes).isEmpty()) {
+        if (nodes instanceof Collection && ((Collection<? extends RexNode>) nodes).isEmpty()) {
             // Optimize common case
             return ImmutableList.of();
         }
@@ -1572,7 +1571,8 @@ public static RexNode flatten(RexBuilder rexBuilder, RexNode node) {
             final SqlOperator op = call.getOperator();
             final List<RexNode> flattenedOperands = flatten(call.getOperands(), op);
             if (!isFlat(call.getOperands(), op)) {
-                return rexBuilder.makeCall(call.getType(), op, flattenedOperands);
+                return rexBuilder.makeCall(
+                        call.getParserPosition(), call.getType(), op, flattenedOperands);
             }
         }
         return node;
@@ -1585,7 +1585,7 @@ public static RexNode flatten(RexBuilder rexBuilder, RexNode node) {
     public static List<RexNode> flatten(List<? extends RexNode> exprs, SqlOperator op) {
         if (isFlat(exprs, op)) {
             //noinspection unchecked
-            return (List) exprs;
+            return (List<RexNode>) exprs;
         }
         final List<RexNode> list = new ArrayList<>();
         flattenRecurse(list, exprs, op);
@@ -2116,7 +2116,7 @@ public static RexNode simplifyAnd2ForUnknownAsFalse(
             case LESS_THAN_OR_EQUAL:
             case GREATER_THAN_OR_EQUAL:
                 final SqlOperator op = op(call.getKind().negateNullSafe());
-                return rexBuilder.makeCall(op, call.getOperands());
+                return rexBuilder.makeCall(call.getParserPosition(), op, call.getOperands());
             default:
                 break;
         }
@@ -2132,7 +2132,8 @@ public static RexNode simplifyAnd2ForUnknownAsFalse(
             case LESS_THAN_OR_EQUAL:
             case GREATER_THAN_OR_EQUAL:
                 final SqlOperator op = requireNonNull(call.getOperator().reverse());
-                return rexBuilder.makeCall(op, Lists.reverse(call.getOperands()));
+                return rexBuilder.makeCall(
+                        call.getParserPosition(), op, Lists.reverse(call.getOperands()));
             default:
                 return null;
         }
@@ -2885,7 +2886,7 @@ public RexNode visitInputRef(RexInputRef ref) {
      * of a given {@link Project}.
      */
     public static class SubQueryCollector extends RexVisitorImpl<Void> {
-        private List<RexSubQuery> subQueries;
+        private final List<RexSubQuery> subQueries;
 
         private SubQueryCollector() {
             super(true);
@@ -3063,16 +3064,46 @@ public boolean inProject(Project project) {
             return anyContain(project.getProjects());
         }
 
+        /** Returns not {@link #inProject(Project)}. */
+        public boolean notInProject(Project project) {
+            return !inProject(project);
+        }
+
         /** Returns whether a {@link Filter} contains the kind of expression we seek. */
         public boolean inFilter(Filter filter) {
             return contains(filter.getCondition());
         }
 
-        /** Returns whether a {@link Join} contains kind of expression we seek. */
+        /** Returns not {@link #inFilter(Filter)}. */
+        public boolean notInFilter(Filter filter) {
+            return !inFilter(filter);
+        }
+
+        /** Returns whether a {@link Calc} contains the kind of expression we seek. */
+        public boolean inCalc(Calc calc) {
+            return inProgram(calc.getProgram());
+        }
+
+        /** Returns not {@link #inCalc(Calc)}. */
+        public boolean notInCalc(Calc calc) {
+            return !inCalc(calc);
+        }
+
+        /** Returns whether a {@link RexProgram} contains the kind of expression we seek. */
+        public boolean inProgram(RexProgram program) {
+            return anyContain(program.getExprList());
+        }
+
+        /** Returns whether a {@link Join} contains the kind of expression we seek. */
         public boolean inJoin(Join join) {
             return contains(join.getCondition());
         }
 
+        /** Returns not {@link #inJoin(Join)}. */
+        public boolean notInJoin(Join join) {
+            return !inJoin(join);
+        }
+
         /** Returns whether the given expression contains what this RexFinder seeks. */
         public boolean contains(RexNode node) {
             try {
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
index 909e0028ae990..11c15a194fa3a 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
@@ -38,22 +38,27 @@
 import org.apache.calcite.linq4j.function.Deterministic;
 import org.apache.calcite.linq4j.function.Experimental;
 import org.apache.calcite.linq4j.function.Function1;
+import org.apache.calcite.linq4j.function.Functions;
 import org.apache.calcite.linq4j.function.NonDeterministic;
 import org.apache.calcite.linq4j.function.Predicate1;
 import org.apache.calcite.linq4j.tree.Primitive;
 import org.apache.calcite.rel.type.TimeFrame;
 import org.apache.calcite.rel.type.TimeFrameSet;
 import org.apache.calcite.runtime.FlatLists.ComparableList;
+import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlUtil;
 import org.apache.calcite.sql.fun.SqlLibraryOperators;
 import org.apache.calcite.util.NumberUtil;
 import org.apache.calcite.util.TimeWithTimeZoneString;
 import org.apache.calcite.util.TimestampWithTimeZoneString;
+import org.apache.calcite.util.TryThreadLocal;
 import org.apache.calcite.util.Unsafe;
 import org.apache.calcite.util.Util;
 import org.apache.calcite.util.format.FormatElement;
 import org.apache.calcite.util.format.FormatModel;
 import org.apache.calcite.util.format.FormatModels;
+import org.apache.calcite.util.format.postgresql.CompiledDateTimeFormat;
+import org.apache.calcite.util.format.postgresql.PostgresqlDateTimeFormatter;
 import org.apache.commons.codec.DecoderException;
 import org.apache.commons.codec.binary.Base32;
 import org.apache.commons.codec.binary.Hex;
@@ -90,6 +95,7 @@
 import java.time.OffsetDateTime;
 import java.time.ZoneId;
 import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeFormatterBuilder;
 import java.time.format.DateTimeParseException;
@@ -122,17 +128,27 @@
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
 
+import static java.lang.Byte.parseByte;
+import static java.lang.Double.parseDouble;
+import static java.lang.Float.parseFloat;
+import static java.lang.Integer.parseInt;
+import static java.lang.Long.parseLong;
+import static java.lang.Short.parseShort;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.Objects.requireNonNull;
+import static java.util.stream.Collectors.joining;
 import static org.apache.calcite.config.CalciteSystemProperty.FUNCTION_LEVEL_CACHE_MAX_SIZE;
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 import static org.apache.calcite.util.Static.RESOURCE;
 
 /**
- * Flink modifications:
+ * Helper methods to implement SQL functions in generated code.
  *
- * <p>so far there are no Flink modifications. Could be removed once upgraded to the version with
- * fixed CALCITE-6393.
+ * <p>Not present: and, or, not (builtin operators are better, because they use lazy evaluation.
+ * Implementations do not check for null values; the calling code must do that.
+ *
+ * <p>Many of the functions do not check for null values. This is intentional. If null arguments are
+ * possible, the code-generation framework checks for nulls before calling the functions.
  */
 @SuppressWarnings("UnnecessaryUnboxing")
 @Deterministic
@@ -194,10 +210,8 @@ public Enumerator<Object[]> enumerator() {
      * parsed, validated and planned. A real application will want persistent values for sequences,
      * shared among threads.
      */
-    private static final ThreadLocal<Map<String, AtomicLong>> THREAD_SEQUENCES =
-            ThreadLocal.withInitial(HashMap::new);
-
-    private static final Pattern PATTERN_0_STAR_E = Pattern.compile("0*E");
+    private static final TryThreadLocal<Map<String, AtomicLong>> THREAD_SEQUENCES =
+            TryThreadLocal.withInitial(HashMap::new);
 
     /** A byte string consisting of a single byte that is the ASCII space character (0x20). */
     private static final ByteString SINGLE_SPACE_BYTE_STRING = ByteString.of("20", 16);
@@ -662,6 +676,11 @@ public int regexpInstr(
             return matchIndex;
         }
 
+        /** SQL {@code REGEXP_REPLACE} function with 2 arguments. */
+        public String regexpReplace(String s, String regex) {
+            return regexpReplace(s, regex, "", 1, 0, null);
+        }
+
         /** SQL {@code REGEXP_REPLACE} function with 3 arguments. */
         public String regexpReplace(String s, String regex, String replacement) {
             return regexpReplace(s, regex, replacement, 1, 0, null);
@@ -672,12 +691,18 @@ public String regexpReplace(String s, String regex, String replacement, int pos)
             return regexpReplace(s, regex, replacement, pos, 0, null);
         }
 
-        /** SQL {@code REGEXP_REPLACE} function with 5 arguments. */
+        /** SQL {@code REGEXP_REPLACE} function with 5 arguments. Last argument is occurrence. */
         public String regexpReplace(
                 String s, String regex, String replacement, int pos, int occurrence) {
             return regexpReplace(s, regex, replacement, pos, occurrence, null);
         }
 
+        /** SQL {@code REGEXP_REPLACE} function with 5 arguments. Last argument is match type */
+        public String regexpReplace(
+                String s, String regex, String replacement, int pos, String matchType) {
+            return regexpReplace(s, regex, replacement, pos, 0, matchType);
+        }
+
         /** SQL {@code REGEXP_REPLACE} function with 6 arguments. */
         public String regexpReplace(
                 String s,
@@ -696,6 +721,19 @@ public String regexpReplace(
             return Unsafe.regexpReplace(s, pattern, replacement, pos, occurrence);
         }
 
+        /** SQL {@code REGEXP_REPLACE} function for PostgreSQL with 3 arguments. */
+        public String regexpReplacePg(String s, String regex, String replacement) {
+            return regexpReplace(s, regex, replacement, 1, 1, null);
+        }
+
+        /** SQL {@code REGEXP_REPLACE} function for PostgreSQL with 4 arguments. */
+        public String regexpReplacePg(
+                String s, String regex, String replacement, String matchType) {
+            // Translate g flag to occurrence
+            final int occurrence = matchType.contains("g") ? 0 : 1;
+            return regexpReplace(s, regex, replacement, 1, occurrence, matchType);
+        }
+
         /**
          * SQL {@code REGEXP_REPLACE} function with 3 arguments with {@code \\} based indexing for
          * capturing groups.
@@ -741,6 +779,11 @@ private static int makeRegexpFlags(String stringFlags) {
                         // for consistency.
                         flags &= ~Pattern.DOTALL;
                         break;
+                    case 'g':
+                        // This flag is in PostgreSQL but doesn't apply to other libraries. Skip
+                        // here since
+                        // this is actually occurrence.
+                        break;
                     default:
                         throw RESOURCE.invalidInputForRegexpReplace(stringFlags).ex();
                 }
@@ -972,9 +1015,9 @@ public static List<ByteString> split(ByteString s, ByteString delimiter) {
      * SQL <code>CONTAINS_SUBSTR(jsonString, substr, json_scope&#61;&#62;jsonScope)</code> operator.
      */
     public static boolean containsSubstr(String jsonString, String substr, String jsonScope) {
-        LinkedHashMap<String, String> map =
-                (LinkedHashMap<String, String>) JsonFunctions.dejsonize(jsonString);
-        assert map != null;
+        final Object o = requireNonNull(JsonFunctions.dejsonize(jsonString));
+        @SuppressWarnings("unchecked")
+        LinkedHashMap<String, String> map = (LinkedHashMap<String, String>) o;
         Set<String> keys = map.keySet();
         Collection<String> values = map.values();
         try {
@@ -1000,7 +1043,7 @@ public static boolean containsSubstr(String jsonString, String substr, String js
     public static boolean containsSubstr(Object expr, String substr) {
         expr = normalize(expr.toString());
         substr = normalize(substr);
-        if (JsonFunctions.isJsonObject(expr.toString())) {
+        if (Boolean.TRUE.equals(JsonFunctions.isJsonObject(expr.toString()))) {
             return containsSubstr(expr.toString(), substr, "JSON_VALUES");
         }
         return ((String) expr).contains(substr);
@@ -1030,18 +1073,6 @@ private static String normalize(String s) {
         return s;
     }
 
-    /** SQL SUBSTRING(string FROM ...) function. */
-    public static String substring(String c, int s) {
-        if (s <= 1) {
-            return c;
-        }
-        if (s > c.length()) {
-            return "";
-        }
-        final int s0 = s - 1;
-        return c.substring(s0);
-    }
-
     // Clamp very large long values to integer values.
     // Used by the substring functions.
     // Java strings do not support long indexes anyway,
@@ -1058,6 +1089,18 @@ static int clamp(long s) {
         return (int) s;
     }
 
+    /** SQL SUBSTRING(string FROM ...) function. */
+    public static String substring(String c, int s) {
+        if (s <= 1) {
+            return c;
+        }
+        if (s > c.length()) {
+            return "";
+        }
+        final int s0 = s - 1;
+        return c.substring(s0);
+    }
+
     public static String substring(String c, long s) {
         return substring(c, clamp(s));
     }
@@ -1080,15 +1123,39 @@ public static String substring(String c, int s, int l) {
     }
 
     public static String substring(String c, int s, long l) {
-        return substring(c, s, clamp(l));
+        if (s < 0) {
+            if (l > 0 && l + s > 0) {
+                l += s;
+                return substring(c, 0, l);
+            }
+        }
+        int l0 = clamp(l);
+        return SqlFunctions.substring(c, s, l0);
     }
 
     public static String substring(String c, long s, int l) {
-        return substring(c, clamp(s), l);
+        if (s < 0) {
+            s += l;
+            if (s > 0) {
+                return substring(c, 0, s);
+            } else {
+                return "";
+            }
+        }
+        int s0 = clamp(s);
+        return SqlFunctions.substring(c, s0, l);
     }
 
     public static String substring(String c, long s, long l) {
-        return substring(c, clamp(s), clamp(l));
+        if (s < 0) {
+            if (l > 0) {
+                l += s;
+                return substring(c, 0, clamp(l));
+            }
+        }
+        int s0 = clamp(s);
+        int l0 = clamp(l);
+        return SqlFunctions.substring(c, s0, l0);
     }
 
     /** SQL SUBSTRING(binary FROM ...) function for binary. */
@@ -1418,7 +1485,7 @@ public static String charFromUtf8(int n) {
 
     /** SQL TO_CODE_POINTS(string) function. */
     public static @Nullable List<Integer> toCodePoints(String s) {
-        if (s.length() == 0) {
+        if (s.isEmpty()) {
             return null;
         }
         final ImmutableList.Builder<Integer> builder = new ImmutableList.Builder<>();
@@ -1544,6 +1611,32 @@ public static String concatMultiWithNull(String... args) {
     public static String concatMultiWithSeparator(String... args) {
         // the separator arg could be null
         final String sep = args[0] == null ? "" : args[0];
+        return concatMultiWithSeparator(sep, args);
+    }
+
+    /** SQL {@code CONCAT_WS(sep[, str | array(str)]+)} function, return null for null sep. */
+    public static String concatMultiTypeWithSeparator(String sep, Object... args) {
+        if (args.length == 0) {
+            return "";
+        }
+        Object[] argsArray = array(args);
+        List<String> arrayList = new ArrayList<>();
+        arrayList.add(sep);
+        for (Object arg : argsArray) {
+            if (arg == null) {
+                continue;
+            }
+            if (arg instanceof String) {
+                arrayList.add((String) arg);
+            }
+            if (arg instanceof List<?>) {
+                arrayList.addAll((List<String>) arg);
+            }
+        }
+        return concatMultiWithSeparator(sep, arrayList.toArray(new String[0]));
+    }
+
+    private static String concatMultiWithSeparator(String sep, String... args) {
         StringBuilder sb = new StringBuilder();
         for (int i = 1; i < args.length; i++) {
             if (args[i] != null) {
@@ -1558,6 +1651,17 @@ public static String concatMultiWithSeparator(String... args) {
         return sb.toString();
     }
 
+    /** SQL {@code CONCAT_WS(sep[, any]+)} function, return null for null sep. */
+    public static String concatMultiObjectWithSeparator(String sep, Object... args) {
+        if (args.length == 0) {
+            return "";
+        }
+        return Arrays.stream(args)
+                .filter(Objects::nonNull)
+                .map(Object::toString)
+                .collect(joining(sep));
+    }
+
     /** SQL {@code CONVERT(s, src_charset, dest_charset)} function. */
     public static String convertWithCharset(String s, String srcCharset, String destCharset) {
         final Charset src = SqlUtil.getCharset(srcCharset);
@@ -2041,6 +2145,14 @@ public static boolean lt(double b0, double b1) {
         return b0 < b1;
     }
 
+    public static boolean lt(List<?> b0, List<?> b1) {
+        return Functions.compareLists(b0, b1) < 0;
+    }
+
+    public static boolean lt(Object[] b0, Object[] b1) {
+        return Functions.compareObjectArrays(b0, b1) < 0;
+    }
+
     /** SQL <code>&lt;</code> operator applied to Object values. */
     public static boolean ltAny(Object b0, Object b1) {
         if (b0.getClass().equals(b1.getClass()) && b0 instanceof Comparable) {
@@ -2080,6 +2192,16 @@ public static boolean le(BigDecimal b0, BigDecimal b1) {
         return b0.compareTo(b1) <= 0;
     }
 
+    /** SQL <code>&le;</code> operator applied to List values. */
+    public static boolean le(List<?> b0, List<?> b1) {
+        return Functions.compareLists(b0, b1) <= 0;
+    }
+
+    /** SQL <code>&le;</code> operator applied to Object[] values. */
+    public static boolean le(Object[] b0, Object[] b1) {
+        return Functions.compareObjectArrays(b0, b1) <= 0;
+    }
+
     /**
      * SQL <code>&le;</code> operator applied to Object values (at least one operand has ANY type;
      * neither may be null).
@@ -2158,6 +2280,14 @@ public static boolean gt(double b0, double b1) {
         return b0 > b1;
     }
 
+    public static boolean gt(List<?> b0, List<?> b1) {
+        return Functions.compareLists(b0, b1) > 0;
+    }
+
+    public static boolean gt(Object[] b0, Object[] b1) {
+        return Functions.compareObjectArrays(b0, b1) > 0;
+    }
+
     /**
      * SQL <code>&gt;</code> operator applied to Object values (at least one operand has ANY type;
      * neither may be null).
@@ -2200,6 +2330,16 @@ public static boolean ge(BigDecimal b0, BigDecimal b1) {
         return b0.compareTo(b1) >= 0;
     }
 
+    /** SQL <code>&ge;</code> operator applied to List values. */
+    public static boolean ge(List<?> b0, List<?> b1) {
+        return Functions.compareLists(b0, b1) >= 0;
+    }
+
+    /** SQL <code>&ge;</code> operator applied to Object[] values. */
+    public static boolean ge(Object[] b0, Object[] b1) {
+        return Functions.compareObjectArrays(b0, b1) >= 0;
+    }
+
     /**
      * SQL <code>&ge;</code> operator applied to Object values (at least one operand has ANY type;
      * neither may be null).
@@ -2708,16 +2848,91 @@ public static long bitAnd(long b0, long b1) {
         return b0 & b1;
     }
 
+    /**
+     * Bitwise function <code>BITAND</code> applied to a Long and int value. Needed for handling
+     * NULL for the first argument.
+     */
+    public static long bitAnd(Long b0, int b1) {
+        return b0 & b1;
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to a Long and int value. Needed for handling
+     * NULL for the second argument.
+     */
+    public static long bitAnd(int b0, Long b1) {
+        return b0 & b1;
+    }
+
     /** Bitwise function <code>BIT_AND</code> applied to binary values. */
     public static ByteString bitAnd(ByteString b0, ByteString b1) {
         return binaryOperator(b0, b1, (x, y) -> (byte) (x & y));
     }
 
+    /**
+     * Helper function for implementing <code>BITCOUNT</code>. Counts the number of bits set in an
+     * integer value.
+     */
+    public static long bitCount(long b) {
+        return Long.bitCount(b);
+    }
+
+    private static final BigDecimal BITCOUNT_MAX =
+            new BigDecimal(2).pow(64).subtract(new BigDecimal(1));
+    private static final BigDecimal BITCOUNT_MIN = new BigDecimal(2).pow(63).negate();
+
+    /**
+     * Helper function for implementing <code>BITCOUNT</code>. Counts the number of bits set in the
+     * integer portion of a decimal value.
+     */
+    public static long bitCount(BigDecimal b) {
+        final int comparison = b.compareTo(BITCOUNT_MAX);
+        if (comparison < 0) {
+            if (b.compareTo(BITCOUNT_MIN) <= 0) {
+                return 1;
+            } else {
+                return bitCount(b.setScale(0, RoundingMode.DOWN).longValue());
+            }
+        } else if (comparison == 0) {
+            return 64;
+        } else {
+            return 63;
+        }
+    }
+
+    /**
+     * Helper function for implementing <code>BITCOUNT</code>. Counts the number of bits set in a
+     * ByteString value.
+     */
+    public static long bitCount(ByteString b) {
+        long bitsSet = 0;
+        for (int i = 0; i < b.length(); i++) {
+            bitsSet += Integer.bitCount(0xff & b.byteAt(i));
+        }
+        return bitsSet;
+    }
+
     /** Bitwise function <code>BIT_OR</code> applied to integer values. */
     public static long bitOr(long b0, long b1) {
         return b0 | b1;
     }
 
+    /**
+     * Bitwise function <code>BITOR</code> applied to a Long and int value. Needed for handling NULL
+     * for the first argument.
+     */
+    public static long bitOr(Long b0, int b1) {
+        return b0 | b1;
+    }
+
+    /**
+     * Bitwise function <code>BITOR</code> applied to a Long and int value. Needed for handling NULL
+     * for the second argument.
+     */
+    public static long bitOr(int b0, Long b1) {
+        return b0 | b1;
+    }
+
     /** Bitwise function <code>BIT_OR</code> applied to binary values. */
     public static ByteString bitOr(ByteString b0, ByteString b1) {
         return binaryOperator(b0, b1, (x, y) -> (byte) (x | y));
@@ -2728,11 +2943,42 @@ public static long bitXor(long b0, long b1) {
         return b0 ^ b1;
     }
 
+    /**
+     * Bitwise function <code>BITXOR</code> applied to a Long and int value. Needed for handling
+     * NULL for the first argument.
+     */
+    public static long bitXor(Long b0, int b1) {
+        return b0 ^ b1;
+    }
+
+    /**
+     * Bitwise function <code>BITXOR</code> applied to a Long and int value. Needed for handling
+     * NULL for the second argument.
+     */
+    public static long bitXor(int b0, Long b1) {
+        return b0 ^ b1;
+    }
+
     /** Bitwise function <code>BIT_XOR</code> applied to binary values. */
     public static ByteString bitXor(ByteString b0, ByteString b1) {
         return binaryOperator(b0, b1, (x, y) -> (byte) (x ^ y));
     }
 
+    /** Bitwise function <code>BIT_NOT</code> applied to integer values. */
+    public static long bitNot(long b) {
+        return ~b;
+    }
+
+    /** Bitwise function <code>BIT_NOT</code> applied to a binary value. */
+    public static ByteString bitNot(ByteString b) {
+        final byte[] result = new byte[b.length()];
+        for (int i = 0; i < b.length(); i++) {
+            result[i] = (byte) ~b.byteAt(i);
+        }
+
+        return new ByteString(result);
+    }
+
     /**
      * Utility for bitwise function applied to two byteString values.
      *
@@ -2794,34 +3040,75 @@ public static double power(BigDecimal b0, BigDecimal b1) {
 
     // LN, LOG, LOG10, LOG2
 
-    /** SQL {@code LOG(number, number2)} function applied to double values. */
-    public static double log(double d0, double d1) {
-        return Math.log(d0) / Math.log(d1);
+    /**
+     * SQL {@code LOG(number, base)} function applied to double values.
+     *
+     * @param nonPositiveIsNull if true return null for non-positive values
+     */
+    public static @Nullable Double log(double number, double base, boolean nonPositiveIsNull) {
+        if (nonPositiveIsNull && number <= 0) {
+            return null;
+        }
+        if (number <= 0 || base <= 0) {
+            throw new IllegalArgumentException("Cannot take logarithm of zero or negative number");
+        }
+        return Math.log(number) / Math.log(base);
     }
 
-    /** SQL {@code LOG(number, number2)} function applied to double and BigDecimal values. */
-    public static double log(double d0, BigDecimal d1) {
-        return Math.log(d0) / Math.log(d1.doubleValue());
+    /**
+     * SQL {@code LOG(number, base)} function applied to double and BigDecimal values.
+     *
+     * @param nonPositiveIsNull if true return null for non-positive values
+     */
+    public static @Nullable Double log(double number, BigDecimal base, boolean nonPositiveIsNull) {
+        if (nonPositiveIsNull && number <= 0) {
+            return null;
+        }
+        if (number <= 0 || base.doubleValue() <= 0) {
+            throw new IllegalArgumentException("Cannot take logarithm of zero or negative number");
+        }
+        return Math.log(number) / Math.log(base.doubleValue());
     }
 
-    /** SQL {@code LOG(number, number2)} function applied to BigDecimal and double values. */
-    public static double log(BigDecimal d0, double d1) {
-        return Math.log(d0.doubleValue()) / Math.log(d1);
+    /**
+     * SQL {@code LOG(number, base)} function applied to BigDecimal and double values.
+     *
+     * @param nonPositiveIsNull if true return null for non-positive values
+     */
+    public static @Nullable Double log(BigDecimal number, double base, Boolean nonPositiveIsNull) {
+        if (nonPositiveIsNull && number.doubleValue() <= 0) {
+            return null;
+        }
+        if (number.doubleValue() <= 0 || base <= 0) {
+            throw new IllegalArgumentException("Cannot take logarithm of zero or negative number");
+        }
+        return Math.log(number.doubleValue()) / Math.log(base);
     }
 
-    /** SQL {@code LOG(number, number2)} function applied to double values. */
-    public static double log(BigDecimal d0, BigDecimal d1) {
-        return Math.log(d0.doubleValue()) / Math.log(d1.doubleValue());
+    /**
+     * SQL {@code LOG(number, base)} function applied to double values.
+     *
+     * @param nonPositiveIsNull if true return null for non-positive values
+     */
+    public static @Nullable Double log(
+            BigDecimal number, BigDecimal base, Boolean nonPositiveIsNull) {
+        if (nonPositiveIsNull && number.doubleValue() <= 0) {
+            return null;
+        }
+        if (number.doubleValue() <= 0 || base.doubleValue() <= 0) {
+            throw new IllegalArgumentException("Cannot take logarithm of zero or negative number");
+        }
+        return Math.log(number.doubleValue()) / Math.log(base.doubleValue());
     }
 
-    /** SQL {@code LOG2(number)} function applied to double values. */
-    public static @Nullable Double log2(double number) {
-        return (number <= 0) ? null : log(number, 2);
+    /** SQL <code>LOG1P</code> operator applied to double values. */
+    public static @Nullable Double log1p(double b0) {
+        return b0 <= -1 ? null : Math.log1p(b0);
     }
 
-    /** SQL {@code LOG2(number)} function applied to BigDecimal values. */
-    public static @Nullable Double log2(BigDecimal number) {
-        return log2(number.doubleValue());
+    /** SQL <code>LOG1P</code> operator applied to BigDecimal values. */
+    public static @Nullable Double log1p(BigDecimal b0) {
+        return b0.doubleValue() <= -1 ? null : Math.log1p(b0.doubleValue());
     }
 
     // MOD
@@ -3027,6 +3314,20 @@ public static double acos(double b0) {
         return Math.acos(b0);
     }
 
+    // ACOSD
+    /** SQL <code>ACOSD</code> operator applied to BigDecimal values. */
+    public static double acosd(BigDecimal b0) {
+        return acosd(b0.doubleValue());
+    }
+
+    /** SQL <code>ACOSD</code> operator applied to double values. */
+    public static double acosd(double b0) {
+        if (b0 < -1.0 || b0 > 1.0) {
+            throw new IllegalArgumentException("input is out of range");
+        }
+        return Math.toDegrees(Math.acos(b0));
+    }
+
     // ACOSH
     /** SQL <code>ACOSH</code> operator applied to BigDecimal values. */
     public static double acosh(BigDecimal b0) {
@@ -3052,6 +3353,20 @@ public static double asin(double b0) {
         return Math.asin(b0);
     }
 
+    // ASIND
+    /** SQL <code>ASIND</code> operator applied to BigDecimal values. */
+    public static double asind(BigDecimal b0) {
+        return asind(b0.doubleValue());
+    }
+
+    /** SQL <code>ASIND</code> operator applied to double values. */
+    public static double asind(double b0) {
+        if (b0 < -1.0 || b0 > 1.0) {
+            throw new IllegalArgumentException("input is out of range");
+        }
+        return Math.toDegrees(Math.asin(b0));
+    }
+
     // ASINH
     /** SQL <code>ASINH</code> operator applied to BigDecimal values. */
     public static double asinh(BigDecimal b0) {
@@ -3082,6 +3397,21 @@ public static double atan(double b0) {
         return Math.atan(b0);
     }
 
+    // ATAND
+    /** SQL <code>ATAN</code> operator applied to BigDecimal values. */
+    public static double atand(BigDecimal b0) {
+        return atand(b0.doubleValue());
+    }
+
+    /** SQL <code>ATAND</code> operator applied to double values. */
+    public static double atand(double b0) {
+        if (Double.isNaN(b0)) {
+            return Double.NaN;
+        } else {
+            return Math.toDegrees(Math.atan(b0));
+        }
+    }
+
     // ATAN2
     /** SQL <code>ATAN2</code> operator applied to double/BigDecimal values. */
     public static double atan2(double b0, BigDecimal b1) {
@@ -3147,6 +3477,21 @@ public static double cos(double b0) {
         return Math.cos(b0);
     }
 
+    // COSD
+    /** SQL <code>COSD</code> operator applied to BigDecimal values. */
+    public static double cosd(BigDecimal b0) {
+        return cosd(b0.doubleValue());
+    }
+
+    /** SQL <code>COSD</code> operator applied to double values. */
+    public static double cosd(double b0) {
+        if (Double.isInfinite(b0)) {
+            throw new IllegalArgumentException("input is out of range");
+        } else {
+            return Math.cos(Math.toRadians(b0));
+        }
+    }
+
     // COSH
     /** SQL <code>COSH</code> operator applied to BigDecimal values. */
     public static double cosh(BigDecimal b) {
@@ -3369,6 +3714,21 @@ public static double sin(double b0) {
         return Math.sin(b0);
     }
 
+    // SIND
+    /** SQL <code>SIND</code> operator applied to BigDecimal values. */
+    public static double sind(BigDecimal b0) {
+        return sind(b0.doubleValue());
+    }
+
+    /** SQL <code>SIND</code> operator applied to double values. */
+    public static double sind(double b0) {
+        if (Double.isInfinite(b0)) {
+            throw new IllegalArgumentException("input is out of range");
+        } else {
+            return Math.sin(Math.toRadians(b0));
+        }
+    }
+
     // SINH
     /** SQL <code>SINH</code> operator applied to BigDecimal values. */
     public static double sinh(BigDecimal b) {
@@ -3391,6 +3751,21 @@ public static double tan(double b0) {
         return Math.tan(b0);
     }
 
+    // TAND
+    /** SQL <code>TAND</code> operator applied to BigDecimal values. */
+    public static double tand(BigDecimal b0) {
+        return tand(b0.doubleValue());
+    }
+
+    /** SQL <code>TAND</code> operator applied to double values. */
+    public static double tand(double b0) {
+        if (Double.isInfinite(b0)) {
+            throw new IllegalArgumentException("input is out of range");
+        } else {
+            return Math.tan(Math.toRadians(b0));
+        }
+    }
+
     // TANH
     /** SQL <code>TANH</code> operator applied to BigDecimal values. */
     public static double tanh(BigDecimal b) {
@@ -3515,9 +3890,7 @@ public static String toString(float x) {
         if (x == 0) {
             return "0E0";
         }
-        BigDecimal bigDecimal = new BigDecimal(x, MathContext.DECIMAL32).stripTrailingZeros();
-        final String s = bigDecimal.toString();
-        return PATTERN_0_STAR_E.matcher(s).replaceAll("E").replace("E+", "E");
+        return Float.toString(x);
     }
 
     /** CAST(DOUBLE AS VARCHAR). */
@@ -3525,9 +3898,7 @@ public static String toString(double x) {
         if (x == 0) {
             return "0E0";
         }
-        BigDecimal bigDecimal = new BigDecimal(x, MathContext.DECIMAL64).stripTrailingZeros();
-        final String s = bigDecimal.toString();
-        return PATTERN_0_STAR_E.matcher(s).replaceAll("E").replace("E+", "E");
+        return Double.toString(x);
     }
 
     /** CAST(DECIMAL AS VARCHAR). */
@@ -3588,7 +3959,7 @@ public static boolean toBoolean(Object o) {
     public static byte toByte(Object o) {
         return o instanceof Byte
                 ? (Byte) o
-                : o instanceof Number ? toByte((Number) o) : Byte.parseByte(o.toString());
+                : o instanceof Number ? toByte((Number) o) : parseByte(o.toString());
     }
 
     public static byte toByte(Number number) {
@@ -3604,7 +3975,7 @@ public static Character toCharBoxed(String s) {
     }
 
     public static short toShort(String s) {
-        return Short.parseShort(s.trim());
+        return parseShort(s.trim());
     }
 
     public static short toShort(Number number) {
@@ -3702,7 +4073,7 @@ public static Integer toIntOptional(java.sql.Time v) {
     }
 
     public static int toInt(String s) {
-        return Integer.parseInt(s.trim());
+        return parseInt(s.trim());
     }
 
     public static int toInt(Number number) {
@@ -3802,7 +4173,7 @@ public static long toLong(String s) {
         if (s.startsWith("199") && s.contains(":")) {
             return Timestamp.valueOf(s).getTime();
         }
-        return Long.parseLong(s.trim());
+        return parseLong(s.trim());
     }
 
     public static long toLong(Number number) {
@@ -3834,7 +4205,7 @@ public static Long toLongOptional(Object o) {
     }
 
     public static float toFloat(String s) {
-        return Float.parseFloat(s.trim());
+        return parseFloat(s.trim());
     }
 
     public static float toFloat(Number number) {
@@ -3852,7 +4223,7 @@ public static float toFloat(Object o) {
     }
 
     public static double toDouble(String s) {
-        return Double.parseDouble(s.trim());
+        return parseDouble(s.trim());
     }
 
     public static double toDouble(Number number) {
@@ -3972,7 +4343,7 @@ public static int timeWithLocalTimeZoneToTime(int v, TimeZone timeZone) {
     public static long timeWithLocalTimeZoneToTimestamp(String date, int v, TimeZone timeZone) {
         final TimeWithTimeZoneString tTZ =
                 TimeWithTimeZoneString.fromMillisOfDay(v).withTimeZone(DateTimeUtils.UTC_ZONE);
-        return new TimestampWithTimeZoneString(date + " " + tTZ.toString())
+        return new TimestampWithTimeZoneString(date + " " + tTZ)
                 .withTimeZone(timeZone)
                 .getLocalTimestampString()
                 .getMillisSinceEpoch();
@@ -3981,7 +4352,7 @@ public static long timeWithLocalTimeZoneToTimestamp(String date, int v, TimeZone
     public static long timeWithLocalTimeZoneToTimestampWithLocalTimeZone(String date, int v) {
         final TimeWithTimeZoneString tTZ =
                 TimeWithTimeZoneString.fromMillisOfDay(v).withTimeZone(DateTimeUtils.UTC_ZONE);
-        return new TimestampWithTimeZoneString(date + " " + tTZ.toString())
+        return new TimestampWithTimeZoneString(date + " " + tTZ)
                 .getLocalTimestampString()
                 .getMillisSinceEpoch();
     }
@@ -3990,6 +4361,16 @@ public static String timeWithLocalTimeZoneToString(int v, TimeZone timeZone) {
         return TimeWithTimeZoneString.fromMillisOfDay(v).withTimeZone(timeZone).toString();
     }
 
+    public static long unixDateExtract(TimeUnitRange range, long date) {
+        return DateTimeUtils.unixDateExtract(range, date);
+    }
+
+    public static long unixDateExtract(String rangeString, long date) {
+        final TimeUnitRange timeUnitRange =
+                TimeUnitRange.of(SqlIntervalQualifier.stringToDatePartTimeUnit(rangeString), null);
+        return DateTimeUtils.unixDateExtract(timeUnitRange, date);
+    }
+
     /**
      * State for {@code FORMAT_DATE}, {@code FORMAT_TIMESTAMP}, {@code FORMAT_DATETIME}, {@code
      * FORMAT_TIME}, {@code TO_CHAR} functions.
@@ -4089,6 +4470,77 @@ public String formatTime(String fmtString, int time) {
         }
     }
 
+    /**
+     * State for {@code FORMAT_DATE}, {@code FORMAT_TIMESTAMP}, {@code FORMAT_DATETIME}, {@code
+     * FORMAT_TIME}, {@code TO_CHAR} functions.
+     */
+    @Deterministic
+    public static class DateFormatFunctionPg {
+        // Timezone to use for PostgreSQL parsing of timestamps
+        private static final ZoneId LOCAL_ZONE = ZoneId.ofOffset("", ZoneOffset.UTC);
+
+        private final DataContext dataContext;
+        private final LoadingCache<String, CompiledDateTimeFormat> formatCachePg =
+                CacheBuilder.newBuilder()
+                        .maximumSize(FUNCTION_LEVEL_CACHE_MAX_SIZE.value())
+                        .build(CacheLoader.from(PostgresqlDateTimeFormatter::compilePattern));
+
+        public DateFormatFunctionPg(DataContext dataContext) {
+            this.dataContext = dataContext;
+        }
+
+        public String toChar(long timestamp, String pattern) {
+            final ZoneId zoneId =
+                    DataContext.Variable.TIME_ZONE.<TimeZone>get(dataContext).toZoneId();
+            final Locale locale = requireNonNull(DataContext.Variable.LOCALE.get(dataContext));
+            final CompiledDateTimeFormat dateTimeFormat = formatCachePg.getUnchecked(pattern);
+            final Timestamp sqlTimestamp = internalToTimestamp(timestamp);
+            final ZonedDateTime zonedDateTime =
+                    ZonedDateTime.of(sqlTimestamp.toLocalDateTime(), zoneId);
+            return dateTimeFormat.formatDateTime(zonedDateTime, locale);
+        }
+
+        public int toDate(String dateString, String fmtString) {
+            try {
+                final Locale locale = requireNonNull(DataContext.Variable.LOCALE.get(dataContext));
+                final CompiledDateTimeFormat dateTimeFormat = formatCachePg.getUnchecked(fmtString);
+                return (int)
+                        dateTimeFormat
+                                .parseDateTime(dateString, LOCAL_ZONE, locale)
+                                .getLong(ChronoField.EPOCH_DAY);
+            } catch (Exception e) {
+                SQLException sqlEx =
+                        new SQLException(
+                                String.format(
+                                        Locale.ROOT,
+                                        "Invalid format: '%s' for datetime string: '%s'.",
+                                        fmtString,
+                                        dateString));
+                throw Util.toUnchecked(sqlEx);
+            }
+        }
+
+        public long toTimestamp(String timestampString, String fmtString) {
+            try {
+                final Locale locale = requireNonNull(DataContext.Variable.LOCALE.get(dataContext));
+                final CompiledDateTimeFormat dateTimeFormat = formatCachePg.getUnchecked(fmtString);
+                return dateTimeFormat
+                        .parseDateTime(timestampString, LOCAL_ZONE, locale)
+                        .toInstant()
+                        .toEpochMilli();
+            } catch (Exception e) {
+                SQLException sqlEx =
+                        new SQLException(
+                                String.format(
+                                        Locale.ROOT,
+                                        "Invalid format: '%s' for timestamp string: '%s'.",
+                                        fmtString,
+                                        timestampString));
+                throw Util.toUnchecked(sqlEx);
+            }
+        }
+    }
+
     /**
      * State for {@code PARSE_DATE}, {@code PARSE_TIMESTAMP}, {@code PARSE_DATETIME}, {@code
      * PARSE_TIME} functions.
@@ -5186,14 +5638,8 @@ public static long sequenceNextValue(String key) {
     }
 
     private static AtomicLong getAtomicLong(String key) {
-        final Map<String, AtomicLong> map =
-                requireNonNull(THREAD_SEQUENCES.get(), "THREAD_SEQUENCES.get()");
-        AtomicLong atomic = map.get(key);
-        if (atomic == null) {
-            atomic = new AtomicLong();
-            map.put(key, atomic);
-        }
-        return atomic;
+        final Map<String, AtomicLong> map = THREAD_SEQUENCES.get();
+        return map.computeIfAbsent(key, key_ -> new AtomicLong());
     }
 
     /** Support the ARRAYS_OVERLAP function. */
@@ -5204,7 +5650,7 @@ private static AtomicLong getAtomicLong(String key) {
         final List smaller = list1;
         final List bigger = list2;
         boolean hasNull = false;
-        if (smaller.size() > 0 && bigger.size() > 0) {
+        if (!smaller.isEmpty() && !bigger.isEmpty()) {
             final Set smallestSet = new HashSet(smaller);
             hasNull = smallestSet.remove(null);
             for (Object element : bigger) {
@@ -5315,7 +5761,7 @@ public static List arrayPrepend(List list, Object element) {
     public static Long arrayPosition(List list, Object element) {
         final int index = list.indexOf(element);
         if (index != -1) {
-            return Long.valueOf(index + 1L);
+            return index + 1L;
         }
         return 0L;
     }
@@ -5514,6 +5960,9 @@ public static Map mapConcat(Map... maps) {
     public static List mapEntries(Map<Object, Object> map) {
         final List result = new ArrayList(map.size());
         for (Map.Entry<Object, Object> entry : map.entrySet()) {
+            if (entry.getKey() == null) {
+                throw RESOURCE.illegalMapEntriesWithNullKey().ex();
+            }
             result.add(Arrays.asList(entry.getKey(), entry.getValue()));
         }
         return result;
@@ -5521,11 +5970,18 @@ public static List mapEntries(Map<Object, Object> map) {
 
     /** Support the MAP_KEYS function. */
     public static List mapKeys(Map map) {
-        return new ArrayList<>(map.keySet());
+        try {
+            return ImmutableList.copyOf(map.keySet());
+        } catch (NullPointerException e) {
+            throw RESOURCE.illegalMapKeysWithNullKey().ex();
+        }
     }
 
     /** Support the MAP_VALUES function. */
     public static List mapValues(Map map) {
+        if (map.containsKey(null)) {
+            throw RESOURCE.illegalMapValuesWithNullKey().ex();
+        }
         return new ArrayList<>(map.values());
     }
 
@@ -5587,6 +6043,55 @@ public static Map strToMap(String string, String stringDelimiter, String keyValu
         return map;
     }
 
+    /** Support the SUBSTRING_INDEX function. */
+    public static String substringIndex(String string, String delimiter, int count) {
+        if (string.isEmpty() || count == 0) {
+            return "";
+        }
+        if (count > 0) {
+            int idx = -1;
+            while (count > 0) {
+                idx = string.indexOf(delimiter, idx + 1);
+                if (idx >= 0) {
+                    count--;
+                } else {
+                    // can not find enough delim
+                    return string;
+                }
+            }
+            if (idx == 0) {
+                return "";
+            }
+            return string.substring(0, idx);
+        } else {
+            int idx = string.length() - delimiter.length() + 1;
+            count = -count;
+            while (count > 0) {
+                idx = rfind(string, delimiter, idx - 1);
+                if (idx >= 0) {
+                    count--;
+                } else {
+                    return string;
+                }
+            }
+            if (idx + delimiter.length() == string.length()) {
+                return "";
+            }
+            return string.substring(idx + delimiter.length());
+        }
+    }
+
+    /** Find the string from right to left. */
+    private static int rfind(String string, String delim, int start) {
+        while (start >= 0) {
+            if (string.indexOf(delim, start) >= 0) {
+                return start;
+            }
+            start -= 1;
+        }
+        return -1;
+    }
+
     /** Support the SLICE function. */
     public static List slice(List list) {
         List result = new ArrayList(list.size());
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java
index 7676b30e0d396..08853d654e617 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java
@@ -33,6 +33,7 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.math.BigDecimal;
+import java.util.Locale;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -321,7 +322,7 @@ public static int combineStartPrecisionPreservingDefault(
 
     public int getFractionalSecondPrecision(RelDataTypeSystem typeSystem) {
         if (fractionalSecondPrecision == RelDataType.PRECISION_NOT_SPECIFIED) {
-            return typeName().getDefaultScale();
+            return typeSystem.getDefaultScale(typeName());
         } else {
             return fractionalSecondPrecision;
         }
@@ -421,6 +422,54 @@ public int getIntervalSign(String value) {
         return sign;
     }
 
+    public static TimeUnit stringToDatePartTimeUnit(String stringValue) {
+        final String timeUnitString = stringValue.toUpperCase(Locale.ROOT);
+
+        switch (timeUnitString) {
+            case "MICROSECOND":
+                return TimeUnit.MICROSECOND;
+            case "MILLISECOND":
+                return TimeUnit.MILLISECOND;
+            case "SECOND":
+                return TimeUnit.SECOND;
+            case "MINUTE":
+                return TimeUnit.MINUTE;
+            case "HOUR":
+                return TimeUnit.HOUR;
+            case "DAY":
+                return TimeUnit.DAY;
+            case "DAYOFWEEK":
+            case "DOW":
+                return TimeUnit.DOW;
+            case "DAYOFYEAR":
+            case "DOY":
+                return TimeUnit.DOY;
+            case "ISODOW":
+                return TimeUnit.ISODOW;
+            case "ISODOY":
+                return TimeUnit.ISOYEAR;
+            case "WEEK":
+                return TimeUnit.WEEK;
+            case "MONTH":
+                return TimeUnit.MONTH;
+            case "QUARTER":
+                return TimeUnit.QUARTER;
+            case "YEAR":
+                return TimeUnit.YEAR;
+            case "EPOCH":
+                return TimeUnit.EPOCH;
+            case "DECADE":
+                return TimeUnit.DECADE;
+            case "CENTURY":
+                return TimeUnit.CENTURY;
+            case "MILLENNIUM":
+                return TimeUnit.MILLENNIUM;
+            default:
+                throw new IllegalArgumentException(
+                        "Date/Time units \"" + stringValue + "\" not recognized");
+        }
+    }
+
     private static String stripLeadingSign(String value) {
         String unsignedValue = value;
 
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java
index feeb06fd232b3..3f2e070228a95 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java
@@ -60,18 +60,18 @@
 import java.nio.charset.StandardCharsets;
 import java.nio.charset.UnsupportedCharsetException;
 import java.sql.DatabaseMetaData;
-import java.sql.SQLException;
 import java.text.MessageFormat;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Objects;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
+import static java.util.Objects.requireNonNull;
 import static org.apache.calcite.util.Static.RESOURCE;
 
 /**
@@ -122,7 +122,9 @@ static ArrayList<SqlNode> flatten(SqlNode node) {
     /** Returns the <code>n</code>th (0-based) input to a join expression. */
     public static SqlNode getFromNode(SqlSelect query, int ordinal) {
         SqlNode from = query.getFrom();
-        assert from != null : "from must not be null for " + query;
+        if (from == null) {
+            throw new AssertionError("from must not be null for " + query);
+        }
         ArrayList<SqlNode> list = flatten(from);
         return list.get(ordinal);
     }
@@ -147,9 +149,7 @@ private static void flatten(SqlNode node, ArrayList<SqlNode> list) {
     /** Converts a SqlNode array to a SqlNodeList. */
     public static SqlNodeList toNodeList(SqlNode[] operands) {
         SqlNodeList ret = new SqlNodeList(SqlParserPos.ZERO);
-        for (SqlNode node : operands) {
-            ret.add(node);
-        }
+        Collections.addAll(ret, operands);
         return ret;
     }
 
@@ -193,10 +193,8 @@ public static boolean isNullLiteral(@Nullable SqlNode node, boolean allowCast) {
         if (allowCast && node != null) {
             if (node.getKind() == SqlKind.CAST) {
                 SqlCall call = (SqlCall) node;
-                if (isNullLiteral(call.operand(0), false)) {
-                    // node is "CAST(NULL as type)"
-                    return true;
-                }
+                // node is "CAST(NULL as type)"
+                return isNullLiteral(call.operand(0), false);
             }
         }
         return false;
@@ -228,7 +226,7 @@ public static boolean isNull(SqlNode node) {
      * @return Whether the node is a literal
      */
     public static boolean isLiteral(SqlNode node, boolean allowCast) {
-        assert node != null;
+        requireNonNull(node, "node");
         if (node instanceof SqlLiteral) {
             return true;
         }
@@ -271,7 +269,7 @@ public static boolean isLiteral(SqlNode node) {
      * @return Whether the node is a literal chain
      */
     public static boolean isLiteralChain(SqlNode node) {
-        assert node != null;
+        requireNonNull(node, "node");
         if (node instanceof SqlCall) {
             SqlCall call = (SqlCall) node;
             return call.getKind() == SqlKind.LITERAL_CHAIN;
@@ -395,7 +393,7 @@ public static void unparseSqlIdentifierSyntax(
                 writer.sep(".");
                 final String name = identifier.names.get(i);
                 final SqlParserPos pos = identifier.getComponentParserPosition(i);
-                if (name.equals("")) {
+                if (name.isEmpty()) {
                     writer.print("*");
                     writer.setNeedWhitespace(true);
                 } else {
@@ -494,7 +492,9 @@ private static Iterator<SqlOperator> filterOperatorRoutinesByKind(
             Iterator<SqlOperator> routines, final SqlKind sqlKind) {
         return Iterators.filter(
                 routines,
-                operator -> Objects.requireNonNull(operator, "operator").getKind() == sqlKind);
+                operator ->
+                        requireNonNull(operator, "operator").getKind().getFunctionKind()
+                                == sqlKind);
     }
 
     /**
@@ -608,8 +608,7 @@ private static Iterator<SqlOperator> lookupSubjectRoutinesByName(
             default:
                 return Iterators.filter(
                         sqlOperators.iterator(),
-                        operator ->
-                                Objects.requireNonNull(operator, "operator").getSyntax() == syntax);
+                        operator -> requireNonNull(operator, "operator").getSyntax() == syntax);
         }
     }
 
@@ -618,7 +617,7 @@ private static Iterator<SqlOperator> filterRoutinesByParameterCount(
         return Iterators.filter(
                 routines,
                 operator ->
-                        Objects.requireNonNull(operator, "operator")
+                        requireNonNull(operator, "operator")
                                 .getOperandCountRange()
                                 .isValidCount(argTypes.size()));
     }
@@ -646,8 +645,7 @@ private static Iterator<SqlOperator> filterRoutinesByParameterTypeAndName(
                         Iterators.filter(routines, SqlFunction.class),
                         function -> {
                             SqlOperandTypeChecker operandTypeChecker =
-                                    Objects.requireNonNull(function, "function")
-                                            .getOperandTypeChecker();
+                                    requireNonNull(function, "function").getOperandTypeChecker();
                             if (operandTypeChecker == null
                                     || !operandTypeChecker.isFixedParameters()) {
                                 // no parameter information for builtins; keep for now,
@@ -800,15 +798,17 @@ public static SqlNode getSelectListItem(SqlNode query, int i) {
         switch (query.getKind()) {
             case SELECT:
                 SqlSelect select = (SqlSelect) query;
-                final SqlNode from = stripAs(select.getFrom());
-                if (from != null && from.getKind() == SqlKind.VALUES) {
-                    // They wrote "VALUES (x, y)", but the validator has
-                    // converted this into "SELECT * FROM VALUES (x, y)".
-                    return getSelectListItem(from, i);
+                SqlNode from = select.getFrom();
+                if (from != null) {
+                    from = stripAs(from);
+                    if (from.getKind() == SqlKind.VALUES) {
+                        // They wrote "VALUES (x, y)", but the validator has
+                        // converted this into "SELECT * FROM VALUES (x, y)".
+                        return getSelectListItem(from, i);
+                    }
                 }
-                final SqlNodeList fields = select.getSelectList();
 
-                assert fields != null : "fields must not be null in " + select;
+                final SqlNodeList fields = select.getSelectList();
                 // Range check the index to avoid index out of range.  This
                 // could be expanded to actually check to see if the select
                 // list is a "*"
@@ -849,8 +849,9 @@ public static String deriveAliasFromOrdinal(int ordinal) {
      * @return true if alias is generated by calcite, otherwise false
      */
     public static boolean isGeneratedAlias(String alias) {
-        assert alias != null;
-        return alias.toUpperCase(Locale.ROOT).startsWith(GENERATED_EXPR_ALIAS_PREFIX);
+        return requireNonNull(alias, "alias")
+                .toUpperCase(Locale.ROOT)
+                .startsWith(GENERATED_EXPR_ALIAS_PREFIX);
     }
 
     /**
@@ -1006,9 +1007,9 @@ public static RelDataType createNlsStringType(RelDataTypeFactory typeFactory, Nl
      *     instance of the Java virtual machine
      */
     public static Charset getCharset(String charsetName) {
-        assert charsetName != null;
-        charsetName = charsetName.toUpperCase(Locale.ROOT);
-        String javaCharsetName = translateCharacterSetName(charsetName);
+        String javaCharsetName =
+                translateCharacterSetName(
+                        requireNonNull(charsetName, "charsetName").toUpperCase(Locale.ROOT));
         if (javaCharsetName == null) {
             throw new UnsupportedCharsetException(charsetName);
         }
@@ -1074,8 +1075,7 @@ public static ImmutableList<SqlNode> getAncestry(
             throw new AssertionError("not found: " + predicate + " in " + root);
         } catch (Util.FoundOne e) {
             //noinspection unchecked
-            return (ImmutableList<SqlNode>)
-                    Objects.requireNonNull(e.getNode(), "Genealogist result");
+            return (ImmutableList<SqlNode>) requireNonNull(e.getNode(), "Genealogist result");
         }
     }
 
@@ -1091,7 +1091,7 @@ public static ImmutableList<SqlNode> getAncestry(
      */
     public static List<RelHint> getRelHint(
             HintStrategyTable hintStrategies, @Nullable SqlNodeList sqlHints) {
-        if (sqlHints == null || sqlHints.size() == 0) {
+        if (sqlHints == null || sqlHints.isEmpty()) {
             return ImmutableList.of();
         }
         final ImmutableList.Builder<RelHint> relHints = ImmutableList.builder();
@@ -1135,7 +1135,7 @@ public static List<RelHint> getRelHint(
     public static RelNode attachRelHint(
             HintStrategyTable hintStrategies, List<RelHint> hints, Hintable rel) {
         final List<RelHint> relHints = hintStrategies.apply(hints, (RelNode) rel);
-        if (relHints.size() > 0) {
+        if (!relHints.isEmpty()) {
             return rel.attachHints(relHints);
         }
         return (RelNode) rel;
@@ -1231,7 +1231,7 @@ public static boolean containsAgg(SqlNode node) {
     }
 
     /** Returns whether an AST tree contains a call that matches a given predicate. */
-    private static boolean containsCall(SqlNode node, Predicate<SqlCall> callPredicate) {
+    public static boolean containsCall(SqlNode node, Predicate<SqlCall> callPredicate) {
         try {
             SqlVisitor<Void> visitor =
                     new SqlBasicVisitor<Void>() {
@@ -1268,11 +1268,11 @@ public DatabaseMetaDataInvocationHandler(
             this.identifierQuoteString = identifierQuoteString;
         }
 
-        public String getDatabaseProductName() throws SQLException {
+        public String getDatabaseProductName() {
             return databaseProductName;
         }
 
-        public String getIdentifierQuoteString() throws SQLException {
+        public String getIdentifierQuoteString() {
             return identifierQuoteString;
         }
     }
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java
new file mode 100644
index 0000000000000..4e691ddf27f5f
--- /dev/null
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java
@@ -0,0 +1,322 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.type;
+
+import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.calcite.sql.SqlCollation;
+import org.apache.calcite.util.SerializableCharset;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.nio.charset.Charset;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * BasicSqlType represents a standard atomic SQL type (excluding interval types).
+ *
+ * <p>Instances of this class are immutable.
+ */
+public class BasicSqlType extends AbstractSqlType {
+    // ~ Static fields/initializers ---------------------------------------------
+
+    // ~ Instance fields --------------------------------------------------------
+
+    private final int precision;
+    private final int scale;
+    protected final RelDataTypeSystem typeSystem;
+    private final @Nullable SqlCollation collation;
+    private final @Nullable SerializableCharset wrappedCharset;
+
+    // ~ Constructors -----------------------------------------------------------
+
+    /**
+     * Constructs a type with no parameters. This should only be called from a factory method.
+     *
+     * @param typeSystem Type system
+     * @param typeName Type name
+     */
+    public BasicSqlType(RelDataTypeSystem typeSystem, SqlTypeName typeName) {
+        this(typeSystem, typeName, false);
+    }
+
+    protected BasicSqlType(RelDataTypeSystem typeSystem, SqlTypeName typeName, boolean nullable) {
+        this(
+                typeSystem,
+                typeName,
+                nullable,
+                PRECISION_NOT_SPECIFIED,
+                SCALE_NOT_SPECIFIED,
+                null,
+                null);
+        checkPrecScale(typeName, false, false);
+    }
+
+    /**
+     * Constructs a type with precision/length but no scale.
+     *
+     * @param typeSystem Type system
+     * @param typeName Type name
+     * @param precision Precision (called length for some types)
+     */
+    public BasicSqlType(RelDataTypeSystem typeSystem, SqlTypeName typeName, int precision) {
+        this(typeSystem, typeName, false, precision, SCALE_NOT_SPECIFIED, null, null);
+        checkPrecScale(typeName, true, false);
+    }
+
+    /**
+     * Constructs a type with precision/length and scale.
+     *
+     * @param typeSystem Type system
+     * @param typeName Type name
+     * @param isNullable nullable
+     * @param precision Precision (called length for some types)
+     */
+    public BasicSqlType(
+            RelDataTypeSystem typeSystem, SqlTypeName typeName, boolean isNullable, int precision) {
+        this(typeSystem, typeName, isNullable, precision, SCALE_NOT_SPECIFIED, null, null);
+        checkPrecScale(typeName, true, false);
+    }
+
+    /**
+     * Constructs a type with precision/length and scale.
+     *
+     * @param typeSystem Type system
+     * @param typeName Type name
+     * @param precision Precision (called length for some types)
+     * @param scale Scale
+     */
+    public BasicSqlType(
+            RelDataTypeSystem typeSystem, SqlTypeName typeName, int precision, int scale) {
+        this(typeSystem, typeName, false, precision, scale, null, null);
+        checkPrecScale(typeName, true, true);
+    }
+
+    /** Internal constructor. */
+    private BasicSqlType(
+            RelDataTypeSystem typeSystem,
+            SqlTypeName typeName,
+            boolean nullable,
+            int precision,
+            int scale,
+            @Nullable SqlCollation collation,
+            @Nullable SerializableCharset wrappedCharset) {
+        super(typeName, nullable, null);
+        this.typeSystem = requireNonNull(typeSystem, "typeSystem");
+        this.precision = precision;
+        this.scale = scale;
+        this.collation = collation;
+        this.wrappedCharset = wrappedCharset;
+        computeDigest();
+    }
+
+    /** Throws if {@code typeName} does not allow the given combination of precision and scale. */
+    protected static void checkPrecScale(
+            SqlTypeName typeName, boolean precisionSpecified, boolean scaleSpecified) {
+        if (!typeName.allowsPrecScale(precisionSpecified, scaleSpecified)) {
+            throw new AssertionError(
+                    "typeName.allowsPrecScale("
+                            + precisionSpecified
+                            + ", "
+                            + scaleSpecified
+                            + "): "
+                            + typeName);
+        }
+    }
+
+    // ~ Methods ----------------------------------------------------------------
+
+    /** Constructs a type with nullablity. */
+    BasicSqlType createWithNullability(boolean nullable) {
+        if (nullable == this.isNullable) {
+            return this;
+        }
+        return new BasicSqlType(
+                this.typeSystem,
+                this.typeName,
+                nullable,
+                this.precision,
+                this.scale,
+                this.collation,
+                this.wrappedCharset);
+    }
+
+    /**
+     * Constructs a type with charset and collation.
+     *
+     * <p>This must be a character type.
+     */
+    BasicSqlType createWithCharsetAndCollation(Charset charset, SqlCollation collation) {
+        checkArgument(SqlTypeUtil.inCharFamily(this));
+        return new BasicSqlType(
+                this.typeSystem,
+                this.typeName,
+                this.isNullable,
+                this.precision,
+                this.scale,
+                collation,
+                SerializableCharset.forCharset(charset));
+    }
+
+    @Override
+    public int getPrecision() {
+        if (precision == PRECISION_NOT_SPECIFIED) {
+            return typeSystem.getDefaultPrecision(typeName);
+        }
+        return precision;
+    }
+
+    @Override
+    public int getScale() {
+        if (scale == SCALE_NOT_SPECIFIED) {
+            switch (typeName) {
+                case TINYINT:
+                case SMALLINT:
+                case INTEGER:
+                case BIGINT:
+                case DECIMAL:
+                    return 0;
+                default:
+                    // fall through
+            }
+        }
+        return scale;
+    }
+
+    @Override
+    public @Nullable Charset getCharset() {
+        return wrappedCharset == null ? null : wrappedCharset.getCharset();
+    }
+
+    @Override
+    public @Nullable SqlCollation getCollation() {
+        return collation;
+    }
+
+    // implement RelDataTypeImpl
+    @Override
+    protected void generateTypeString(StringBuilder sb, boolean withDetail) {
+        // Called to make the digest, which equals() compares;
+        // so equivalent data types must produce identical type strings.
+
+        sb.append(typeName.name());
+        boolean printPrecision = precision != PRECISION_NOT_SPECIFIED;
+        boolean printScale = scale != SCALE_NOT_SPECIFIED;
+
+        if (printPrecision) {
+            sb.append('(');
+            sb.append(getPrecision());
+            if (printScale) {
+                sb.append(", ");
+                sb.append(getScale());
+            }
+            sb.append(')');
+        }
+        if (!withDetail) {
+            return;
+        }
+        if (wrappedCharset != null
+                && !SqlCollation.IMPLICIT.getCharset().equals(wrappedCharset.getCharset())) {
+            sb.append(" CHARACTER SET \"");
+            sb.append(wrappedCharset.getCharset().name());
+            sb.append("\"");
+        }
+        if (collation != null
+                && collation != SqlCollation.IMPLICIT
+                && collation != SqlCollation.COERCIBLE) {
+            sb.append(" COLLATE \"");
+            sb.append(collation.getCollationName());
+            sb.append("\"");
+        }
+    }
+
+    /**
+     * Returns a value which is a limit for this type.
+     *
+     * <p>For example,
+     *
+     * <table border="1">
+     * <caption>Limits</caption>
+     * <tr>
+     * <th>Datatype</th>
+     * <th>sign</th>
+     * <th>limit</th>
+     * <th>beyond</th>
+     * <th>precision</th>
+     * <th>scale</th>
+     * <th>Returns</th>
+     * </tr>
+     * <tr>
+     * <td>Integer</td>
+     * <td>true</td>
+     * <td>true</td>
+     * <td>false</td>
+     * <td>-1</td>
+     * <td>-1</td>
+     * <td>2147483647 (2 ^ 31 -1 = MAXINT)</td>
+     * </tr>
+     * <tr>
+     * <td>Integer</td>
+     * <td>true</td>
+     * <td>true</td>
+     * <td>true</td>
+     * <td>-1</td>
+     * <td>-1</td>
+     * <td>2147483648 (2 ^ 31 = MAXINT + 1)</td>
+     * </tr>
+     * <tr>
+     * <td>Integer</td>
+     * <td>false</td>
+     * <td>true</td>
+     * <td>false</td>
+     * <td>-1</td>
+     * <td>-1</td>
+     * <td>-2147483648 (-2 ^ 31 = MININT)</td>
+     * </tr>
+     * <tr>
+     * <td>Boolean</td>
+     * <td>true</td>
+     * <td>true</td>
+     * <td>false</td>
+     * <td>-1</td>
+     * <td>-1</td>
+     * <td>TRUE</td>
+     * </tr>
+     * <tr>
+     * <td>Varchar</td>
+     * <td>true</td>
+     * <td>true</td>
+     * <td>false</td>
+     * <td>10</td>
+     * <td>-1</td>
+     * <td>'ZZZZZZZZZZ'</td>
+     * </tr>
+     * </table>
+     *
+     * @param sign If true, returns upper limit, otherwise lower limit
+     * @param limit If true, returns value at or near to overflow; otherwise value at or near to
+     *     underflow
+     * @param beyond If true, returns the value just beyond the limit, otherwise the value at the
+     *     limit
+     * @return Limit value
+     */
+    public @Nullable Object getLimit(boolean sign, SqlTypeName.Limit limit, boolean beyond) {
+        int precision = typeName.allowsPrec() ? this.getPrecision() : -1;
+        int scale = typeName.allowsScale() ? this.getScale() : -1;
+        return typeName.getLimit(sign, limit, beyond, precision, scale);
+    }
+}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
index 50a979faa517f..ed808ead90eea 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
@@ -30,6 +30,7 @@
 import java.util.List;
 
 import static java.util.Objects.requireNonNull;
+import static org.apache.calcite.util.Static.RESOURCE;
 
 /**
  * Default implementation {@link SqlTypeFactoryImpl}, the class was copied over because of
@@ -65,13 +66,13 @@ public RelDataType createSqlType(SqlTypeName typeName) {
 
     @Override
     public RelDataType createSqlType(SqlTypeName typeName, int precision) {
+        if (typeName.allowsScale()) {
+            return createSqlType(typeName, precision, typeName.getDefaultScale());
+        }
         final int maxPrecision = typeSystem.getMaxPrecision(typeName);
         if (maxPrecision >= 0 && precision > maxPrecision) {
             precision = maxPrecision;
         }
-        if (typeName.allowsScale()) {
-            return createSqlType(typeName, precision, typeName.getDefaultScale());
-        }
         assertBasic(typeName);
         assert (precision >= 0) || (precision == RelDataType.PRECISION_NOT_SPECIFIED);
         // Does not check precision when typeName is SqlTypeName#NULL.
@@ -91,6 +92,17 @@ public RelDataType createSqlType(SqlTypeName typeName, int precision, int scale)
         if (maxPrecision >= 0 && precision > maxPrecision) {
             precision = maxPrecision;
         }
+        if (precision != RelDataType.PRECISION_NOT_SPECIFIED
+                && precision < typeSystem.getMinPrecision(typeName)) {
+            throw RESOURCE.invalidPrecisionForDecimalType(precision, maxPrecision).ex();
+        }
+        if (scale != RelDataType.SCALE_NOT_SPECIFIED && scale < typeSystem.getMinScale(typeName)) {
+            throw RESOURCE.invalidScaleForDecimalType(
+                            scale,
+                            typeSystem.getMinScale(typeName),
+                            typeSystem.getMaxNumericScale())
+                    .ex();
+        }
         RelDataType newType = new BasicSqlType(typeSystem, typeName, precision, scale);
         newType = SqlTypeUtil.addCharsetAndCollation(newType, this);
         return canonize(newType);
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
index 0ec5a90a5ba25..94ac1cd34d3d2 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
@@ -18,7 +18,6 @@
 
 import org.apache.flink.sql.parser.type.ExtendedSqlRowTypeNameSpec;
 
-import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Sets;
 import org.apache.calcite.rel.type.RelDataType;
@@ -51,6 +50,7 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.nio.charset.Charset;
 import java.util.AbstractList;
 import java.util.ArrayList;
@@ -61,6 +61,7 @@
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import static com.google.common.base.Preconditions.checkArgument;
 import static java.util.Objects.requireNonNull;
 import static org.apache.calcite.rel.type.RelDataTypeImpl.NON_NULLABLE_SUFFIX;
 import static org.apache.calcite.sql.type.NonNullableAccessors.getCharset;
@@ -315,6 +316,10 @@ public static RelDataType keepSourceTypeAndTargetNullability(
             RelDataType sourceRelDataType,
             RelDataType targetRelDataType,
             RelDataTypeFactory typeFactory) {
+        checkArgument(
+                (targetRelDataType.isStruct() && sourceRelDataType.isStruct())
+                        || (!targetRelDataType.isStruct() && !sourceRelDataType.isStruct()),
+                "one is a struct, while the other one is not");
         if (!targetRelDataType.isStruct()) {
             return typeFactory.createTypeWithNullability(
                     sourceRelDataType, targetRelDataType.isNullable());
@@ -1051,12 +1056,15 @@ public static SqlDataTypeSpec convertTypeToSpec(
                 || isNull(type)
                 || type.getSqlTypeName() == SqlTypeName.UNKNOWN
                 || type.getSqlTypeName() == SqlTypeName.GEOMETRY) {
-            int precision = typeName.allowsPrec() ? type.getPrecision() : -1;
+            int precision =
+                    typeName.allowsPrec()
+                            ? type.getPrecision()
+                            : RelDataType.PRECISION_NOT_SPECIFIED;
             // fix up the precision.
             if (maxPrecision > 0 && precision > maxPrecision) {
                 precision = maxPrecision;
             }
-            int scale = typeName.allowsScale() ? type.getScale() : -1;
+            int scale = typeName.allowsScale() ? type.getScale() : RelDataType.SCALE_NOT_SPECIFIED;
             if (maxScale > 0 && scale > maxScale) {
                 scale = maxScale;
             }
@@ -1119,7 +1127,11 @@ public static SqlDataTypeSpec convertTypeToSpec(
     public static SqlDataTypeSpec convertTypeToSpec(RelDataType type) {
         // TODO jvs 28-Dec-2004:  collation
         String charSetName = inCharFamily(type) ? type.getCharset().name() : null;
-        return convertTypeToSpec(type, charSetName, -1, -1);
+        return convertTypeToSpec(
+                type,
+                charSetName,
+                RelDataType.PRECISION_NOT_SPECIFIED,
+                RelDataType.SCALE_NOT_SPECIFIED);
     }
 
     public static RelDataType createMultisetType(
@@ -1146,7 +1158,7 @@ public static RelDataType createMapType(
     /** Creates a MAP type from a record type. The record type must have exactly two fields. */
     public static RelDataType createMapTypeFromRecord(
             RelDataTypeFactory typeFactory, RelDataType type) {
-        Preconditions.checkArgument(
+        checkArgument(
                 type.getFieldCount() == 2,
                 "MAP requires exactly two fields, got %s; row type %s",
                 type.getFieldCount(),
@@ -1257,8 +1269,8 @@ public static boolean equalSansNullability(RelDataType type1, RelDataType type2)
      */
     public static boolean equalAsCollectionSansNullability(
             RelDataTypeFactory factory, RelDataType type1, RelDataType type2) {
-        Preconditions.checkArgument(isCollection(type1), "Input type1 must be collection type");
-        Preconditions.checkArgument(isCollection(type2), "Input type2 must be collection type");
+        checkArgument(isCollection(type1), "Input type1 must be collection type");
+        checkArgument(isCollection(type2), "Input type2 must be collection type");
 
         return (type1 == type2)
                 || (type1.getSqlTypeName() == type2.getSqlTypeName()
@@ -1280,8 +1292,8 @@ && equalSansNullability(
      */
     public static boolean equalAsMapSansNullability(
             RelDataTypeFactory factory, RelDataType type1, RelDataType type2) {
-        Preconditions.checkArgument(isMap(type1), "Input type1 must be map type");
-        Preconditions.checkArgument(isMap(type2), "Input type2 must be map type");
+        checkArgument(isMap(type1), "Input type1 must be map type");
+        checkArgument(isMap(type2), "Input type2 must be map type");
 
         MapSqlType mType1 = (MapSqlType) type1;
         MapSqlType mType2 = (MapSqlType) type2;
@@ -1308,8 +1320,8 @@ public static boolean equalAsStructSansNullability(
             RelDataType type1,
             RelDataType type2,
             @Nullable SqlNameMatcher nameMatcher) {
-        Preconditions.checkArgument(type1.isStruct(), "Input type1 must be struct type");
-        Preconditions.checkArgument(type2.isStruct(), "Input type2 must be struct type");
+        checkArgument(type1.isStruct(), "Input type1 must be struct type");
+        checkArgument(type2.isStruct(), "Input type2 must be struct type");
 
         if (type1 == type2) {
             return true;
@@ -1412,7 +1424,8 @@ public static boolean isFlat(RelDataType type) {
 
     /**
      * Returns whether two types are comparable. They need to be scalar types of the same family, or
-     * struct types whose fields are pairwise comparable.
+     * struct types whose fields are pairwise comparable. Note that types in the CHARACTER family
+     * are comparable with many other types (see {@link #canConvertStringInCompare}).
      *
      * @param type1 First type
      * @param type2 Second type
@@ -1765,6 +1778,33 @@ public static RelDataType extractLastNFields(
                 type.getFieldList().subList(fieldsCnt - numToKeep, fieldsCnt));
     }
 
+    /**
+     * Returns whether the decimal value can be represented without information loss using the
+     * specified type. For example, 1111.11 - cannot be represented exactly using DECIMAL(3, 1)
+     * since it overflows. - cannot be represented exactly using DECIMAL(6, 3) since it overflows. -
+     * cannot be represented exactly using DECIMAL(6, 1) since it requires rounding. - can be
+     * represented exactly using DECIMAL(6, 2)
+     *
+     * @param value A decimal value
+     * @param toType A DECIMAL type.
+     * @return whether the value is valid for the type
+     */
+    public static boolean canBeRepresentedExactly(@Nullable BigDecimal value, RelDataType toType) {
+        assert toType.getSqlTypeName() == SqlTypeName.DECIMAL;
+        if (value == null) {
+            return true;
+        }
+        value = value.stripTrailingZeros();
+        if (value.scale() < 0) {
+            // Negative scale, convert to 0 scale.
+            // Rounding mode is irrelevant, since value is integer
+            value = value.setScale(0, RoundingMode.DOWN);
+        }
+        final int intDigits = value.precision() - value.scale();
+        final int maxIntDigits = toType.getPrecision() - toType.getScale();
+        return (intDigits <= maxIntDigits) && (value.scale() <= toType.getScale());
+    }
+
     /**
      * Returns whether the decimal value is valid for the type. For example, 1111.11 is not valid
      * for DECIMAL(3, 1) since it overflows.
@@ -1786,4 +1826,36 @@ public static boolean isValidDecimalValue(@Nullable BigDecimal value, RelDataTyp
                 return true;
         }
     }
+
+    /**
+     * Strips MEASURE wrappers from a type.
+     *
+     * <p>For example:
+     *
+     * <ul>
+     *   <li>"{@code INTEGER}" remains "{@code INTEGER}";
+     *   <li>"{@code MEASURE<DECIMAL>}" becomes "{@code DECIMAL}";
+     *   <li>"{@code (empno INTEGER NOT NULL, rating MEASURE<DECIMAL>)}" becomes "{@code (empno
+     *       INTEGER NOT NULL, rating DECIMAL)}".
+     * </ul>
+     */
+    public static RelDataType fromMeasure(RelDataTypeFactory typeFactory, RelDataType type) {
+        if (type.isStruct()) {
+            final RelDataTypeFactory.Builder builder = typeFactory.builder();
+            int changeCount = 0;
+            for (RelDataTypeField field : type.getFieldList()) {
+                final RelDataType type2 = fromMeasure(typeFactory, field.getType());
+                if (type2 != field.getType()) {
+                    ++changeCount;
+                }
+                builder.add(field.getName(), type2);
+            }
+            // Avoid the effort of re-creating the same type
+            return changeCount == 0 ? type : builder.build();
+        }
+        if (type.isMeasure()) {
+            return ((MeasureSqlType) type).types.get(0);
+        }
+        return type;
+    }
 }
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index b7d9b6eb48824..e100df7031579 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -21,6 +21,7 @@
 import org.apache.flink.table.planner.functions.sql.ml.SqlVectorSearchTableFunction;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 import org.apache.calcite.linq4j.Ord;
@@ -55,6 +56,8 @@
 import org.apache.calcite.sql.SqlAccessEnum;
 import org.apache.calcite.sql.SqlAccessType;
 import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.SqlAsOperator;
+import org.apache.calcite.sql.SqlAsofJoin;
 import org.apache.calcite.sql.SqlBasicCall;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlCallBinding;
@@ -79,6 +82,7 @@
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlOperatorTable;
 import org.apache.calcite.sql.SqlOrderBy;
+import org.apache.calcite.sql.SqlOverOperator;
 import org.apache.calcite.sql.SqlPivot;
 import org.apache.calcite.sql.SqlSampleSpec;
 import org.apache.calcite.sql.SqlSelect;
@@ -97,6 +101,7 @@
 import org.apache.calcite.sql.SqlWithItem;
 import org.apache.calcite.sql.TableCharacteristic;
 import org.apache.calcite.sql.fun.SqlCase;
+import org.apache.calcite.sql.fun.SqlInternalOperators;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.type.AssignableOperandTypeChecker;
@@ -133,7 +138,6 @@
 import org.slf4j.Logger;
 
 import java.math.BigDecimal;
-import java.math.BigInteger;
 import java.util.AbstractList;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
@@ -171,6 +175,7 @@
 import static org.apache.calcite.sql.type.NonNullableAccessors.getCharset;
 import static org.apache.calcite.sql.type.NonNullableAccessors.getCollation;
 import static org.apache.calcite.sql.validate.SqlNonNullableAccessors.getCondition;
+import static org.apache.calcite.sql.validate.SqlNonNullableAccessors.getMatchCondition;
 import static org.apache.calcite.sql.validate.SqlNonNullableAccessors.getTable;
 import static org.apache.calcite.util.Static.RESOURCE;
 import static org.apache.calcite.util.Util.first;
@@ -255,7 +260,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
      */
     protected final IdentityHashMap<SqlNode, SqlValidatorScope> scopes = new IdentityHashMap<>();
 
-    /** Maps a {@link SqlSelect} and a clause to the scope used by that clause. */
+    /** Maps a {@link SqlSelect} and a {@link Clause} to the scope used by that clause. */
     private final Map<IdPair<SqlSelect, Clause>, SqlValidatorScope> clauseScopes = new HashMap<>();
 
     /** The name-resolution scope of a LATERAL TABLE clause. */
@@ -361,11 +366,7 @@ protected SqlValidatorImpl(
 
         if (config.conformance().allowLenientCoercion()) {
             final SqlTypeCoercionRule rules =
-                    requireNonNull(
-                            config.typeCoercionRules() != null
-                                    ? config.typeCoercionRules()
-                                    : SqlTypeCoercionRule.THREAD_PROVIDERS.get(),
-                            "rules");
+                    first(config.typeCoercionRules(), SqlTypeCoercionRule.instance());
 
             final ImmutableSet<SqlTypeName> arrayMapping =
                     ImmutableSet.<SqlTypeName>builder()
@@ -426,7 +427,7 @@ public SqlNodeList expandStar(
             SqlNodeList selectList, SqlSelect select, boolean includeSystemVars) {
         final List<SqlNode> list = new ArrayList<>();
         final PairList<String, RelDataType> types = PairList.of();
-        for (SqlNode selectItem : selectList) {
+        for (final SqlNode selectItem : selectList) {
             final RelDataType originalType = getValidatedNodeTypeIfKnown(selectItem);
             expandSelectItem(
                     selectItem,
@@ -500,19 +501,26 @@ private boolean expandSelectItem(
             Set<String> aliases,
             PairList<String, RelDataType> fields,
             boolean includeSystemVars) {
-        final SelectScope scope = (SelectScope) getWhereScope(select);
-        if (expandStar(selectItems, aliases, fields, includeSystemVars, scope, selectItem)) {
-            return true;
-        }
+        final SqlValidatorScope selectScope;
+        SqlNode expanded;
+        if (SqlValidatorUtil.isMeasure(selectItem)) {
+            selectScope = getMeasureScope(select);
+            expanded = selectItem;
+        } else {
+            final SelectScope scope = (SelectScope) getWhereScope(select);
+            if (expandStar(selectItems, aliases, fields, includeSystemVars, scope, selectItem)) {
+                return true;
+            }
 
-        // Expand the select item: fully-qualify columns, and convert
-        // parentheses-free functions such as LOCALTIME into explicit function
-        // calls.
-        SqlNode expanded = expandSelectExpr(selectItem, scope, select);
+            // Expand the select item: fully-qualify columns, and convert
+            // parentheses-free functions such as LOCALTIME into explicit function
+            // calls.
+            selectScope = getSelectScope(select);
+            expanded = expandSelectExpr(selectItem, scope, select);
+        }
         final String alias = SqlValidatorUtil.alias(selectItem, aliases.size());
 
         // If expansion has altered the natural alias, supply an explicit 'AS'.
-        final SqlValidatorScope selectScope = getSelectScope(select);
         if (expanded != selectItem) {
             String newAlias = SqlValidatorUtil.alias(expanded, aliases.size());
             if (!Objects.equals(newAlias, alias)) {
@@ -552,6 +560,8 @@ private static SqlNode expandExprFromJoin(
             return identifier;
         }
 
+        final Map<String, String> fieldAliases = getFieldAliases(scope);
+
         for (String name : SqlIdentifier.simpleNames((SqlNodeList) getCondition(join))) {
             if (identifier.getSimple().equals(name)) {
                 final List<SqlNode> qualifiedNode = new ArrayList<>();
@@ -566,11 +576,23 @@ private static SqlNode expandExprFromJoin(
                 }
 
                 assert qualifiedNode.size() == 2;
-                return SqlStdOperatorTable.AS.createCall(
-                        SqlParserPos.ZERO,
+
+                // If there is an alias for the column, no need to wrap the coalesce with an AS
+                // operator
+                boolean haveAlias = fieldAliases.containsKey(name);
+
+                final SqlCall coalesceCall =
                         SqlStdOperatorTable.COALESCE.createCall(
-                                SqlParserPos.ZERO, qualifiedNode.get(0), qualifiedNode.get(1)),
-                        new SqlIdentifier(name, SqlParserPos.ZERO));
+                                SqlParserPos.ZERO, qualifiedNode.get(0), qualifiedNode.get(1));
+
+                if (haveAlias) {
+                    return coalesceCall;
+                } else {
+                    return SqlStdOperatorTable.AS.createCall(
+                            SqlParserPos.ZERO,
+                            coalesceCall,
+                            new SqlIdentifier(name, SqlParserPos.ZERO));
+                }
             }
         }
 
@@ -584,6 +606,26 @@ private static SqlNode expandExprFromJoin(
         }
     }
 
+    private static Map<String, String> getFieldAliases(final SelectScope scope) {
+        final ImmutableMap.Builder<String, String> fieldAliases = new ImmutableMap.Builder<>();
+
+        for (SqlNode selectItem : scope.getNode().getSelectList()) {
+            if (selectItem instanceof SqlCall) {
+                final SqlCall call = (SqlCall) selectItem;
+                if (!(call.getOperator() instanceof SqlAsOperator)
+                        || !(call.operand(0) instanceof SqlIdentifier)) {
+                    continue;
+                }
+
+                final SqlIdentifier fieldIdentifier = call.operand(0);
+                fieldAliases.put(
+                        fieldIdentifier.getSimple(), ((SqlIdentifier) call.operand(1)).getSimple());
+            }
+        }
+
+        return fieldAliases.build();
+    }
+
     /**
      * Returns the set of field names in the join condition specified by USING or implicitly by
      * NATURAL, de-duplicated and in order.
@@ -680,6 +722,7 @@ private boolean expandStar(
         if (!identifier.isStar()) {
             return false;
         }
+        final int originalSize = selectItems.size();
         final SqlParserPos startPosition = identifier.getParserPosition();
         switch (identifier.names.size()) {
             case 1:
@@ -746,7 +789,7 @@ private boolean expandStar(
                 if (!hasDynamicStruct || Bug.CALCITE_2400_FIXED) {
                     // If some fields before star identifier,
                     // we should move offset.
-                    int offset = calculatePermuteOffset(selectItems);
+                    int offset = Math.min(calculatePermuteOffset(selectItems), originalSize);
                     new Permute(from, offset).permute(selectItems, fields);
                 }
                 return true;
@@ -948,11 +991,11 @@ private void lookupJoinHints(
         SqlNode right = join.getRight();
         SqlNode condition = join.getCondition();
         lookupFromHints(left, scope, pos, hintList);
-        if (hintList.size() > 0) {
+        if (!hintList.isEmpty()) {
             return;
         }
         lookupFromHints(right, scope, pos, hintList);
-        if (hintList.size() > 0) {
+        if (!hintList.isEmpty()) {
             return;
         }
         final JoinConditionType conditionType = join.getConditionType();
@@ -984,7 +1027,7 @@ public final void lookupNameCompletionHints(
         // Remove the last part of name - it is a dummy
         List<String> subNames = Util.skipLast(names);
 
-        if (subNames.size() > 0) {
+        if (!subNames.isEmpty()) {
             // If there's a prefix, resolve it to a namespace.
             SqlValidatorNamespace ns = null;
             for (String name : subNames) {
@@ -1131,7 +1174,7 @@ public void validateQuery(SqlNode node, SqlValidatorScope scope, RelDataType tar
             default:
                 break;
         }
-        if (node == top) {
+        if (node == top && !config.embeddedQuery()) {
             validateModality(node);
         }
         validateAccess(node, ns.getTable(), SqlAccessEnum.SELECT);
@@ -1148,9 +1191,9 @@ public void validateQuery(SqlNode node, SqlValidatorScope scope, RelDataType tar
     protected void validateNamespace(
             final SqlValidatorNamespace namespace, RelDataType targetRowType) {
         namespace.validate(targetRowType);
-        SqlNode node = namespace.getNode();
+        final SqlNode node = namespace.getNode();
         if (node != null) {
-            setValidatedNodeType(node, namespace.getType());
+            RelDataType type = namespace.getType();
 
             if (node == top) {
                 // A top-level namespace must not return any must-filter fields.
@@ -1166,7 +1209,12 @@ protected void validateNamespace(
                     throw newValidationError(
                             node, RESOURCE.mustFilterFieldsMissing(fieldNameSet.toString()));
                 }
+
+                if (!config.embeddedQuery()) {
+                    type = SqlTypeUtil.fromMeasure(typeFactory, type);
+                }
             }
+            setValidatedNodeType(node, type);
         }
     }
 
@@ -1195,6 +1243,11 @@ public SqlValidatorScope getSelectScope(SqlSelect select) {
         return getScope(select, Clause.SELECT);
     }
 
+    @Override
+    public SqlValidatorScope getMeasureScope(SqlSelect select) {
+        return getScope(select, Clause.MEASURE);
+    }
+
     @Override
     public @Nullable SelectScope getRawSelectScope(SqlSelect select) {
         SqlValidatorScope scope = clauseScopes.get(IdPair.of(select, Clause.SELECT));
@@ -1712,7 +1765,7 @@ private SqlNode rewriteUpdateToMerge(SqlUpdate updateCall, SqlNode selfJoinSrcEx
         }
         SqlNode selfJoinTgtExpr =
                 getSelfJoinExprForUpdate(updateCall.getTargetTable(), updateAlias.getSimple());
-        assert selfJoinTgtExpr != null;
+        requireNonNull(selfJoinTgtExpr, "selfJoinTgtExpr");
 
         // Create join condition between source and target exprs,
         // creating a conjunction with the user-level WHERE
@@ -1867,7 +1920,7 @@ protected SqlSelect createSourceSelectForDelete(SqlDelete call) {
      */
     @Nullable RelDataType getTableConstructorRowType(SqlCall values, SqlValidatorScope scope) {
         final List<SqlNode> rows = values.getOperandList();
-        assert rows.size() >= 1;
+        assert !rows.isEmpty();
         final List<RelDataType> rowTypes = new ArrayList<>();
         for (final SqlNode row : rows) {
             assert row.getKind() == SqlKind.ROW;
@@ -2013,7 +2066,7 @@ public RelDataType deriveConstructorType(
             @Nullable SqlFunction resolvedConstructor,
             List<RelDataType> argTypes) {
         SqlIdentifier sqlIdentifier = unresolvedConstructor.getSqlIdentifier();
-        assert sqlIdentifier != null;
+        requireNonNull(sqlIdentifier, "sqlIdentifier");
         RelDataType type = catalogReader.getNamedType(sqlIdentifier);
         if (type == null) {
             // TODO jvs 12-Feb-2005:  proper type name formatting
@@ -2187,6 +2240,13 @@ protected void inferUnknownTypes(
         } else if (node.getKind() == SqlKind.AS) {
             // For AS operator, only infer the operand not the alias
             inferUnknownTypes(inferredType, scope, ((SqlCall) node).operand(0));
+        } else if (node.getKind() == SqlKind.MEASURE) {
+            // For MEASURE operator, use the measure scope (which has additional
+            // aliases available)
+            if (scope instanceof SelectScope) {
+                scope = getMeasureScope(((SelectScope) scope).getNode());
+            }
+            inferUnknownTypes(inferredType, scope, ((SqlCall) node).operand(0));
         } else if (node instanceof SqlCall) {
             final SqlCall call = (SqlCall) node;
             final SqlOperandTypeInference operandTypeInference =
@@ -2384,6 +2444,8 @@ protected void registerNamespace(
      *     tree are visible in the scope
      * @return registered node, usually the same as {@code node}
      */
+    // CHECKSTYLE: OFF
+    // CheckStyle thinks this method is too long
     private SqlNode registerFrom(
             SqlValidatorScope parentScope0,
             SqlValidatorScope usingScope,
@@ -2563,6 +2625,7 @@ private SqlNode registerFrom(
                 boolean forceRightNullable = forceNullable;
                 switch (join.getJoinType()) {
                     case LEFT:
+                    case LEFT_ASOF:
                         forceRightNullable = true;
                         break;
                     case RIGHT:
@@ -2619,7 +2682,7 @@ private SqlNode registerFrom(
                     tableScope = new TableScope(parentScope, node);
                 }
                 tableScope.addChild(newNs, requireNonNull(alias, "alias"), forceNullable);
-                if (extendList != null && extendList.size() != 0) {
+                if (extendList != null && !extendList.isEmpty()) {
                     return enclosingNode;
                 }
                 return newNode;
@@ -2779,7 +2842,7 @@ private SqlNode registerFrom(
                         extendList,
                         forceNullable,
                         lateral);
-                if (extendList != null && extendList.size() != 0) {
+                if (extendList != null && !extendList.isEmpty()) {
                     return enclosingNode;
                 }
                 return newNode;
@@ -2825,6 +2888,8 @@ private SqlNode registerFrom(
         }
     }
 
+    // CHECKSTYLE: ON
+
     protected boolean shouldAllowOverRelation() {
         return false;
     }
@@ -2936,29 +3001,30 @@ private void registerQuery(
                 // If this is an aggregate query, the SELECT list and HAVING
                 // clause use a different scope, where you can only reference
                 // columns which are in the GROUP BY clause.
-                SqlValidatorScope aggScope = selectScope;
-                if (isAggregate(select)) {
-                    aggScope = new AggregatingSelectScope(selectScope, select, false);
-                    clauseScopes.put(IdPair.of(select, Clause.SELECT), aggScope);
-                } else {
-                    clauseScopes.put(IdPair.of(select, Clause.SELECT), selectScope);
-                }
+                final SqlValidatorScope selectScope2 =
+                        isAggregate(select)
+                                ? new AggregatingSelectScope(selectScope, select, false)
+                                : selectScope;
+                clauseScopes.put(IdPair.of(select, Clause.SELECT), selectScope2);
+                clauseScopes.put(
+                        IdPair.of(select, Clause.MEASURE), new MeasureScope(selectScope, select));
                 if (select.getGroup() != null) {
                     GroupByScope groupByScope =
                             new GroupByScope(selectScope, select.getGroup(), select);
                     clauseScopes.put(IdPair.of(select, Clause.GROUP_BY), groupByScope);
                     registerSubQueries(groupByScope, select.getGroup());
                 }
-                registerOperandSubQueries(aggScope, select, SqlSelect.HAVING_OPERAND);
-                registerSubQueries(aggScope, SqlNonNullableAccessors.getSelectList(select));
+                registerOperandSubQueries(selectScope2, select, SqlSelect.HAVING_OPERAND);
+                registerSubQueries(selectScope2, SqlNonNullableAccessors.getSelectList(select));
                 final SqlNodeList orderList = select.getOrderList();
                 if (orderList != null) {
                     // If the query is 'SELECT DISTINCT', restrict the columns
                     // available to the ORDER BY clause.
-                    if (select.isDistinct()) {
-                        aggScope = new AggregatingSelectScope(selectScope, select, true);
-                    }
-                    OrderByScope orderScope = new OrderByScope(aggScope, orderList, select);
+                    final SqlValidatorScope selectScope3 =
+                            select.isDistinct()
+                                    ? new AggregatingSelectScope(selectScope, select, true)
+                                    : selectScope2;
+                    OrderByScope orderScope = new OrderByScope(selectScope3, orderList, select);
                     clauseScopes.put(IdPair.of(select, Clause.ORDER), orderScope);
                     registerSubQueries(orderScope, orderList);
 
@@ -3170,7 +3236,7 @@ private void registerSetop(
             // recursive scope is only set for the recursive queries.
             recursiveScope =
                     scope != null && scope.recursiveScope != null
-                            ? Objects.requireNonNull(scope.recursiveScope)
+                            ? requireNonNull(scope.recursiveScope)
                             : parentScope;
         }
         for (int i = 0; i < call.getOperandList().size(); i++) {
@@ -3366,20 +3432,21 @@ public void validateIdentifier(SqlIdentifier id, SqlValidatorScope scope) {
     public void validateLiteral(SqlLiteral literal) {
         switch (literal.getTypeName()) {
             case DECIMAL:
-                // Decimal and long have the same precision (as 64-bit integers), so
-                // the unscaled value of a decimal must fit into a long.
-
-                // REVIEW jvs 4-Aug-2004:  This should probably be calling over to
-                // the available calculator implementations to see what they
-                // support.  For now use ESP instead.
-                //
-                // jhyde 2006/12/21: I think the limits should be baked into the
-                // type system, not dependent on the calculator implementation.
-                BigDecimal bd = literal.getValueAs(BigDecimal.class);
-                BigInteger unscaled = bd.unscaledValue();
-                long longValue = unscaled.longValue();
-                if (!BigInteger.valueOf(longValue).equals(unscaled)) {
-                    // overflow
+                // Accept any decimal value that does not exceed the max
+                // precision and scale of the type system.
+                final RelDataTypeSystem typeSystem = getTypeFactory().getTypeSystem();
+                final BigDecimal bd = literal.getValueAs(BigDecimal.class);
+                final BigDecimal noTrailingZeros = bd.stripTrailingZeros();
+                // If we don't strip trailing zeros we may reject values such as 1.000....0.
+
+                final int maxPrecision = typeSystem.getMaxNumericPrecision();
+                if (noTrailingZeros.precision() > maxPrecision) {
+                    throw newValidationError(
+                            literal, RESOURCE.numberLiteralOutOfRange(bd.toString()));
+                }
+
+                final int maxScale = typeSystem.getMaxNumericScale();
+                if (noTrailingZeros.scale() > maxScale) {
                     throw newValidationError(
                             literal, RESOURCE.numberLiteralOutOfRange(bd.toString()));
                 }
@@ -3459,7 +3526,7 @@ private void validateLiteralAsDouble(SqlLiteral literal) {
 
     @Override
     public void validateIntervalQualifier(SqlIntervalQualifier qualifier) {
-        assert qualifier != null;
+        requireNonNull(qualifier, "qualifier");
         boolean startPrecisionOutOfRange = false;
         boolean fractionalSecondPrecisionOutOfRange = false;
         final RelDataTypeSystem typeSystem = typeFactory.getTypeSystem();
@@ -3467,8 +3534,8 @@ public void validateIntervalQualifier(SqlIntervalQualifier qualifier) {
         final int startPrecision = qualifier.getStartPrecision(typeSystem);
         final int fracPrecision = qualifier.getFractionalSecondPrecision(typeSystem);
         final int maxPrecision = typeSystem.getMaxPrecision(qualifier.typeName());
-        final int minPrecision = qualifier.typeName().getMinPrecision();
-        final int minScale = qualifier.typeName().getMinScale();
+        final int minPrecision = typeSystem.getMinPrecision(qualifier.typeName());
+        final int minScale = typeSystem.getMinScale(qualifier.typeName());
         final int maxScale = typeSystem.getMaxScale(qualifier.typeName());
         if (startPrecision < minPrecision || startPrecision > maxPrecision) {
             startPrecisionOutOfRange = true;
@@ -3715,11 +3782,156 @@ protected void validateJoin(SqlJoin join, SqlValidatorScope scope) {
                             join.getConditionTypeNode(), RESOURCE.crossJoinDisallowsCondition());
                 }
                 break;
+            case LEFT_ASOF:
+            case ASOF:
+                {
+                    // In addition to the standard join checks, the ASOF join requires the
+                    // ON conditions to be a conjunction of simple equalities from both relations.
+                    SqlAsofJoin asof = (SqlAsofJoin) join;
+                    SqlNode matchCondition = getMatchCondition(asof);
+                    matchCondition = expand(matchCondition, joinScope);
+                    join.setOperand(6, matchCondition);
+                    validateWhereOrOn(joinScope, matchCondition, "MATCH_CONDITION");
+                    SqlNode condition = join.getCondition();
+                    if (condition == null) {
+                        throw newValidationError(join, RESOURCE.joinRequiresCondition());
+                    }
+                    ConjunctionOfEqualities conj = new ConjunctionOfEqualities();
+                    condition.accept(conj);
+                    if (conj.illegal) {
+                        throw newValidationError(
+                                condition, RESOURCE.asofConditionMustBeComparison());
+                    }
+
+                    CompareFromBothSides validateCompare =
+                            new CompareFromBothSides(
+                                    joinScope,
+                                    catalogReader,
+                                    RESOURCE.asofConditionMustBeComparison());
+                    condition.accept(validateCompare);
+
+                    // It also requires the MATCH condition to be a comparison.
+                    if (!(matchCondition instanceof SqlCall)) {
+                        throw newValidationError(
+                                matchCondition, RESOURCE.asofMatchMustBeComparison());
+                    }
+                    SqlCall matchCall = (SqlCall) matchCondition;
+                    SqlOperator operator = matchCall.getOperator();
+                    if (!SqlKind.ORDER_COMPARISON.contains(operator.kind)) {
+                        throw newValidationError(
+                                matchCondition, RESOURCE.asofMatchMustBeComparison());
+                    }
+
+                    // Change the exception in validateCompare when we validate the match condition
+                    validateCompare =
+                            new CompareFromBothSides(
+                                    joinScope, catalogReader, RESOURCE.asofMatchMustBeComparison());
+                    matchCondition.accept(validateCompare);
+                    break;
+                }
             default:
                 throw Util.unexpected(joinType);
         }
     }
 
+    /**
+     * Shuttle which determines whether all SqlCalls that are comparisons are comparing columns from
+     * both namespaces. The shuttle will throw an exception if that happens. If it returns all
+     * SqlCalls have the expected shape.
+     */
+    private class CompareFromBothSides extends SqlShuttle {
+        final SqlValidatorScope scope;
+        final SqlValidatorCatalogReader catalogReader;
+        final Resources.ExInst<SqlValidatorException> exception;
+
+        private CompareFromBothSides(
+                SqlValidatorScope scope,
+                SqlValidatorCatalogReader catalogReader,
+                Resources.ExInst<SqlValidatorException> exception) {
+            this.scope = scope;
+            this.catalogReader = catalogReader;
+            this.exception = exception;
+        }
+
+        @Override
+        public @Nullable SqlNode visit(final SqlCall call) {
+            SqlKind kind = call.getKind();
+            if (SqlKind.COMPARISON.contains(kind)) {
+                assert call.getOperandList().size() == 2;
+
+                boolean leftFound = false;
+                boolean rightFound = false;
+                // The two sides of the comparison must be from different tables
+                for (SqlNode operand : call.getOperandList()) {
+                    if (!(operand instanceof SqlIdentifier)) {
+                        throw newValidationError(call, this.exception);
+                    }
+                    // We know that all identifiers have been expanded by the caller,
+                    // so they have the shape namespace.field
+                    SqlIdentifier id = (SqlIdentifier) operand;
+                    final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
+                    final SqlValidatorScope.ResolvedImpl resolved =
+                            new SqlValidatorScope.ResolvedImpl();
+                    // Lookup just the first component of the name
+                    scope.resolve(
+                            id.names.subList(0, id.names.size() - 1), nameMatcher, false, resolved);
+                    SqlValidatorScope.Resolve resolve = resolved.only();
+                    int index = resolve.path.steps().get(0).i;
+                    if (index == 0) {
+                        leftFound = true;
+                    }
+                    if (index == 1) {
+                        rightFound = true;
+                    }
+
+                    if (!leftFound && !rightFound) {
+                        throw newValidationError(call, this.exception);
+                    }
+                }
+                if (!leftFound || !rightFound) {
+                    // The comparison does not look at both tables
+                    throw newValidationError(call, this.exception);
+                }
+            }
+            return super.visit(call);
+        }
+    }
+
+    /** Shuttle which determines whether an expression is a simple conjunction of equalities. */
+    private static class ConjunctionOfEqualities extends SqlShuttle {
+        boolean illegal = false;
+
+        // Check an AND node.  Children can be AND nodes or EQUAL nodes.
+        void checkAnd(SqlCall call) {
+            // This doesn't seem to use the visitor pattern,
+            // because we recurse explicitly on the tree structure.
+            // The visitor is useful to make sure no other kinds of operations
+            // appear in the expression tree.
+            List<SqlNode> operands = call.getOperandList();
+            for (SqlNode operand : operands) {
+                if (operand.getKind() == SqlKind.AND) {
+                    this.checkAnd((SqlCall) operand);
+                    return;
+                }
+                if (operand.getKind() != SqlKind.EQUALS) {
+                    illegal = true;
+                }
+            }
+        }
+
+        @Override
+        public @Nullable SqlNode visit(final org.apache.calcite.sql.SqlCall call) {
+            SqlKind kind = call.getKind();
+            if (kind != SqlKind.AND && kind != SqlKind.EQUALS) {
+                illegal = true;
+            }
+            if (kind == SqlKind.AND) {
+                this.checkAnd(call);
+            }
+            return super.visit(call);
+        }
+    }
+
     /**
      * Throws an error if there is an aggregate or windowed aggregate in the given clause.
      *
@@ -3993,6 +4205,9 @@ public Void visit(SqlIdentifier id) {
     private void checkRollUpInSelectList(SqlSelect select) {
         SqlValidatorScope scope = getSelectScope(select);
         for (SqlNode item : SqlNonNullableAccessors.getSelectList(select)) {
+            if (SqlValidatorUtil.isMeasure(item)) {
+                continue;
+            }
             checkRollUp(null, select, item, scope);
         }
     }
@@ -4169,7 +4384,9 @@ private boolean isRolledUpColumnAllowedInAgg(
 
     private static @Nullable Table resolveTable(SqlIdentifier identifier, SqlValidatorScope scope) {
         SqlQualified fullyQualified = scope.fullyQualify(identifier);
-        assert fullyQualified.namespace != null : "namespace must not be null in " + fullyQualified;
+        if (fullyQualified.namespace == null) {
+            throw new IllegalArgumentException("namespace must not be null in " + fullyQualified);
+        }
         SqlValidatorTable sqlValidatorTable = fullyQualified.namespace.getTable();
         if (sqlValidatorTable != null) {
             return sqlValidatorTable.table();
@@ -4323,7 +4540,7 @@ public boolean validateModality(SqlSelect select, SqlModality modality, boolean
 
         // Make sure that ORDER BY is possible.
         final SqlNodeList orderList = select.getOrderList();
-        if (orderList != null && orderList.size() > 0) {
+        if (orderList != null && !orderList.isEmpty()) {
             switch (modality) {
                 case STREAM:
                     if (!hasSortedPrefix(scope, orderList)) {
@@ -4508,12 +4725,12 @@ public TypeCoercion getTypeCoercion() {
 
     @Override
     public Config config() {
-        return this.config;
+        return requireNonNull(this.config, "config");
     }
 
     @Override
     public SqlValidator transform(UnaryOperator<Config> transform) {
-        this.config = transform.apply(this.config);
+        this.config = requireNonNull(transform.apply(this.config), "config");
         return this;
     }
 
@@ -4608,14 +4825,30 @@ private void validateOrderItem(SqlSelect select, SqlNode orderItem) {
 
     @Override
     public SqlNode expandOrderExpr(SqlSelect select, SqlNode orderExpr) {
-        final SqlNode newSqlNode = new OrderExpressionExpander(select, orderExpr).go();
-        if (newSqlNode != orderExpr) {
-            final SqlValidatorScope scope = getOrderScope(select);
-            inferUnknownTypes(unknownType, scope, newSqlNode);
-            final RelDataType type = deriveType(scope, newSqlNode);
-            setValidatedNodeType(newSqlNode, type);
+        final SqlNode orderExpr2 = new OrderExpressionExpander(select, orderExpr).go();
+        if (orderExpr2 == orderExpr) {
+            return orderExpr2;
+        }
+
+        final SqlValidatorScope scope = getOrderScope(select);
+        inferUnknownTypes(unknownType, scope, orderExpr2);
+        final RelDataType type = deriveType(scope, orderExpr2);
+        setValidatedNodeType(orderExpr2, type);
+        if (!type.isMeasure()) {
+            return orderExpr2;
         }
-        return newSqlNode;
+
+        final SqlNode orderExpr3 = measureToValue(orderExpr2);
+        final RelDataType type3 = deriveType(scope, orderExpr3);
+        setValidatedNodeType(orderExpr3, type3);
+        return orderExpr3;
+    }
+
+    private static SqlNode measureToValue(SqlNode e) {
+        if (e.getKind() == SqlKind.V2M) {
+            return ((SqlCall) e).operand(0);
+        }
+        return SqlInternalOperators.M2V.createCall(e.getParserPosition(), e);
     }
 
     /**
@@ -4669,7 +4902,7 @@ protected void validateGroupClause(SqlSelect select) {
             aggregatingScope = (AggregatingSelectScope) selectScope;
         }
         for (SqlNode groupItem : groupList) {
-            if (groupItem instanceof SqlNodeList && ((SqlNodeList) groupItem).size() == 0) {
+            if (groupItem instanceof SqlNodeList && ((SqlNodeList) groupItem).isEmpty()) {
                 continue;
             }
             validateGroupItem(groupScope, aggregatingScope, groupItem);
@@ -4758,6 +4991,7 @@ protected void validateHavingClause(SqlSelect select) {
         if (having == null) {
             return;
         }
+        SqlNode originalHaving = having;
         final AggregatingScope havingScope = (AggregatingScope) getSelectScope(select);
         if (config.conformance().isHavingAlias()) {
             SqlNode newExpr = extendedExpand(having, havingScope, select, Clause.HAVING);
@@ -4766,6 +5000,9 @@ protected void validateHavingClause(SqlSelect select) {
                 select.setHaving(newExpr);
             }
         }
+        if (SqlUtil.containsCall(having, call -> call.getOperator() instanceof SqlOverOperator)) {
+            throw newValidationError(originalHaving, RESOURCE.windowInHavingNotAllowed());
+        }
         havingScope.checkAggregateExpr(having, true);
         inferUnknownTypes(booleanType, havingScope, having);
         having.validate(this, havingScope);
@@ -4823,7 +5060,11 @@ protected RelDataType validateSelectList(
         // something other than unknownType for targetRowType
         inferUnknownTypes(targetRowType, selectScope, newSelectList);
 
+        final boolean aggregate = isAggregate(select) || select.isDistinct();
         for (SqlNode selectItem : expandedSelectItems) {
+            if (SqlValidatorUtil.isMeasure(selectItem) && aggregate) {
+                throw newValidationError(selectItem, RESOURCE.measureInAggregateQuery());
+            }
             validateNoAggs(groupFinder, selectItem, "SELECT");
             validateExpr(selectItem, selectScope);
         }
@@ -4857,6 +5098,10 @@ private void validateExpr(SqlNode expr, SqlValidatorScope scope) {
             throw newValidationError(expr, RESOURCE.measureMustBeInAggregateQuery());
         }
 
+        if (SqlValidatorUtil.isMeasure(expr) && scope instanceof SelectScope) {
+            scope = getMeasureScope(((SelectScope) scope).getNode());
+        }
+
         // Call on the expression to validate itself.
         expr.validateExpr(this, scope);
 
@@ -4915,10 +5160,14 @@ private void handleScalarSubQuery(
      * @param targetColumnList List of target columns, or null if not specified
      * @param append Whether to append fields to those in <code>
      *                         baseRowType</code>
+     * @param targetTableAlias Target table alias, or null if not specified
      * @return Rowtype
      */
     protected RelDataType createTargetRowType(
-            SqlValidatorTable table, @Nullable SqlNodeList targetColumnList, boolean append) {
+            SqlValidatorTable table,
+            @Nullable SqlNodeList targetColumnList,
+            boolean append,
+            @Nullable SqlIdentifier targetTableAlias) {
         RelDataType baseRowType = table.getRowType();
         if (targetColumnList == null) {
             return baseRowType;
@@ -4934,6 +5183,15 @@ protected RelDataType createTargetRowType(
         final RelOptTable relOptTable = table instanceof RelOptTable ? ((RelOptTable) table) : null;
         for (SqlNode node : targetColumnList) {
             SqlIdentifier id = (SqlIdentifier) node;
+            if (!id.isSimple() && targetTableAlias != null) {
+                // checks that target column identifiers are prefixed with the target
+                // table alias
+                SqlIdentifier prefixId = id.skipLast(1);
+                if (!prefixId.toString().equals(targetTableAlias.toString())) {
+                    throw newValidationError(
+                            prefixId, RESOURCE.unknownIdentifier(prefixId.toString()));
+                }
+            }
             RelDataTypeField targetField =
                     SqlValidatorUtil.getTargetField(
                             baseRowType, typeFactory, id, catalogReader, relOptTable);
@@ -4967,7 +5225,7 @@ public void validateInsert(SqlInsert insert) {
         // reduce the rowtype to the columns specified.  If not present
         // then the entire target rowtype is used.
         final RelDataType targetRowType =
-                createTargetRowType(table, insert.getTargetColumnList(), false);
+                createTargetRowType(table, insert.getTargetColumnList(), false, null);
 
         final SqlNode source = insert.getSource();
         if (source instanceof SqlSelect) {
@@ -5064,7 +5322,8 @@ private void checkConstraint(
             final List<SqlNode> values = ((SqlCall) source).getOperandList();
             for (final int colIndex : constrainedTargetColumns) {
                 final String colName = tableFields.get(colIndex).getName();
-                final RelDataTypeField targetField = tableIndexToTargetField.get(colIndex);
+                final RelDataTypeField targetField =
+                        requireNonNull(tableIndexToTargetField.get(colIndex));
                 for (SqlNode row : values) {
                     final SqlCall call = (SqlCall) row;
                     final SqlNode sourceValue = call.operand(targetField.getIndex());
@@ -5383,7 +5642,7 @@ public void validateUpdate(SqlUpdate call) {
                         : relOptTable.unwrapOrThrow(SqlValidatorTable.class);
 
         final RelDataType targetRowType =
-                createTargetRowType(table, call.getTargetColumnList(), true);
+                createTargetRowType(table, call.getTargetColumnList(), true, call.getAlias());
 
         final SqlSelect select = SqlNonNullableAccessors.getSourceSelect(call);
         validateSelect(select, targetRowType);
@@ -5423,12 +5682,15 @@ public void validateMerge(SqlMerge call) {
         SqlUpdate updateCall = call.getUpdateCall();
         if (updateCall != null) {
             requireNonNull(table, () -> "ns.getTable() for " + targetNamespace);
-            targetRowType = createTargetRowType(table, updateCall.getTargetColumnList(), true);
+            targetRowType =
+                    createTargetRowType(
+                            table, updateCall.getTargetColumnList(), true, call.getAlias());
         }
         SqlInsert insertCall = call.getInsertCall();
         if (insertCall != null) {
             requireNonNull(table, () -> "ns.getTable() for " + targetNamespace);
-            targetRowType = createTargetRowType(table, insertCall.getTargetColumnList(), false);
+            targetRowType =
+                    createTargetRowType(table, insertCall.getTargetColumnList(), false, null);
         }
 
         validateSelect(sqlSelect, targetRowType);
@@ -5654,7 +5916,7 @@ public ValidationErrorFunction getValidationErrorFunction() {
     @Override
     public CalciteContextException newValidationError(
             SqlNode node, Resources.ExInst<SqlValidatorException> e) {
-        assert node != null;
+        requireNonNull(node, "node");
         final SqlParserPos pos = node.getParserPosition();
         return SqlUtil.newContextException(pos, e);
     }
@@ -5781,38 +6043,34 @@ public void validateMatchRecognize(SqlCall call) {
         final RelDataTypeFactory.Builder typeBuilder = typeFactory.builder();
 
         // parse PARTITION BY column
-        SqlNodeList partitionBy = matchRecognize.getPartitionList();
-        if (partitionBy != null) {
-            for (SqlNode node : partitionBy) {
-                SqlIdentifier identifier = (SqlIdentifier) node;
-                identifier.validate(this, scope);
-                RelDataType type = deriveType(scope, identifier);
-                String name = identifier.names.get(1);
-                typeBuilder.add(name, type);
-            }
+        for (SqlNode node : matchRecognize.getPartitionList()) {
+            SqlIdentifier identifier = (SqlIdentifier) node;
+            identifier.validate(this, scope);
+            RelDataType type = deriveType(scope, identifier);
+            String name = identifier.names.get(1);
+            typeBuilder.add(name, type);
         }
 
         // parse ORDER BY column
-        SqlNodeList orderBy = matchRecognize.getOrderList();
-        if (orderBy != null) {
-            for (SqlNode node : orderBy) {
-                node.validate(this, scope);
-                SqlIdentifier identifier;
-                if (node instanceof SqlBasicCall) {
-                    identifier = ((SqlBasicCall) node).operand(0);
-                } else {
-                    identifier =
-                            requireNonNull(
-                                    (SqlIdentifier) node,
-                                    () -> "order by field is null. All fields: " + orderBy);
-                }
+        for (SqlNode node : matchRecognize.getOrderList()) {
+            node.validate(this, scope);
+            SqlIdentifier identifier;
+            if (node instanceof SqlBasicCall) {
+                identifier = ((SqlBasicCall) node).operand(0);
+            } else {
+                identifier =
+                        requireNonNull(
+                                (SqlIdentifier) node,
+                                () ->
+                                        "order by field is null. All fields: "
+                                                + matchRecognize.getOrderList());
+            }
 
-                if (allRows) {
-                    RelDataType type = deriveType(scope, identifier);
-                    String name = identifier.names.get(1);
-                    if (!typeBuilder.nameExists(name)) {
-                        typeBuilder.add(name, type);
-                    }
+            if (allRows) {
+                RelDataType type = deriveType(scope, identifier);
+                String name = identifier.names.get(1);
+                if (!typeBuilder.nameExists(name)) {
+                    typeBuilder.add(name, type);
                 }
             }
         }
@@ -5842,11 +6100,11 @@ public void validateMatchRecognize(SqlCall call) {
                         RESOURCE.intervalMustBeNonNegative(
                                 intervalValue != null ? intervalValue : interval.toString()));
             }
-            if (orderBy == null || orderBy.size() == 0) {
+            if (matchRecognize.getOrderList().isEmpty()) {
                 throw newValidationError(interval, RESOURCE.cannotUseWithinWithoutOrderBy());
             }
 
-            SqlNode firstOrderByColumn = orderBy.get(0);
+            SqlNode firstOrderByColumn = matchRecognize.getOrderList().get(0);
             SqlIdentifier identifier;
             if (firstOrderByColumn instanceof SqlBasicCall) {
                 identifier = ((SqlBasicCall) firstOrderByColumn).operand(0);
@@ -5867,7 +6125,7 @@ public void validateMatchRecognize(SqlCall call) {
         validateDefinitions(matchRecognize, scope);
 
         SqlNodeList subsets = matchRecognize.getSubsetList();
-        if (subsets != null && subsets.size() > 0) {
+        if (!subsets.isEmpty()) {
             for (SqlNode node : subsets) {
                 List<SqlNode> operands = ((SqlCall) node).getOperandList();
                 String leftString = ((SqlIdentifier) operands.get(0)).getSimple();
@@ -6361,8 +6619,7 @@ public void validateAggregateParams(
                                 orderList, RESOURCE.orderByRequiresOneKey(op.getName()));
                     }
                     // Validate that the ORDER BY field is of NUMERIC type
-                    SqlNode node = orderList.get(0);
-                    assert node != null;
+                    SqlNode node = requireNonNull(orderList.get(0));
                     final RelDataType type = deriveType(scope, node);
                     final @Nullable SqlTypeFamily family = type.getSqlTypeName().getFamily();
                     if (family == null || family.allowableDifferenceTypes().isEmpty()) {
@@ -6702,7 +6959,7 @@ private static class MergeNamespace extends DmlNamespace {
 
     /** Visitor that retrieves pattern variables defined. */
     private static class PatternVarVisitor implements SqlVisitor<Void> {
-        private MatchRecognizeScope scope;
+        private final MatchRecognizeScope scope;
 
         PatternVarVisitor(MatchRecognizeScope scope) {
             this.scope = scope;
@@ -6848,7 +7105,7 @@ public RelDataType visit(SqlIdentifier id) {
             for (; i < id.names.size(); i++) {
                 String name = id.names.get(i);
                 final RelDataTypeField field;
-                if (name.equals("")) {
+                if (name.isEmpty()) {
                     // The wildcard "*" is represented as an empty name. It never
                     // resolves to a field.
                     name = "*";
@@ -7342,7 +7599,7 @@ private static class NavigationExpander extends NavigationModifier {
                 return newInnerNode;
             }
 
-            if (operands.size() > 0) {
+            if (!operands.isEmpty()) {
                 for (SqlNode node : operands) {
                     if (node != null) {
                         SqlNode newNode = node.accept(new NavigationExpander());
@@ -7533,7 +7790,7 @@ public Set<String> visit(SqlCall call) {
                         }
                         break;
                     default:
-                        if (operands.size() == 0
+                        if (operands.isEmpty()
                                 || !(operands.get(0) instanceof SqlCall)
                                 || ((SqlCall) operands.get(0)).getOperator()
                                         != SqlStdOperatorTable.CLASSIFIER) {
@@ -7662,7 +7919,9 @@ private class Permute {
 
         private RelDataTypeField field(String name) {
             RelDataTypeField field = catalogReader.nameMatcher().field(rowType, name);
-            assert field != null : "field " + name + " was not found in " + rowType;
+            if (field == null) {
+                throw new AssertionError("field " + name + " was not found in " + rowType);
+            }
             return field;
         }
 
@@ -7735,6 +7994,7 @@ private enum Clause {
         WHERE,
         GROUP_BY,
         SELECT,
+        MEASURE,
         ORDER,
         CURSOR,
         HAVING,
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/AggConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/AggConverter.java
index 849d222f6a845..5cd0848922237 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/AggConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/AggConverter.java
@@ -26,6 +26,7 @@
 import org.apache.calcite.rel.RelFieldCollation;
 import org.apache.calcite.rel.core.AggregateCall;
 import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexNode;
@@ -42,6 +43,8 @@
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlSelectKeyword;
 import org.apache.calcite.sql.SqlUtil;
+import org.apache.calcite.sql.fun.SqlInternalOperators;
+import org.apache.calcite.sql.fun.SqlLibraryOperators;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.util.SqlVisitor;
@@ -60,6 +63,7 @@
 import java.util.stream.Collectors;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
+import static org.apache.calcite.sql.type.SqlTypeUtil.fromMeasure;
 
 /**
  * FLINK modifications are at lines
@@ -226,6 +230,15 @@ private void addExpr(RexNode expr, @Nullable String name) {
 
     @Override
     public Void visit(SqlIdentifier id) {
+        if (isMeasureExpr(id)) {
+            final SqlCall call = SqlInternalOperators.AGG_M2V.createCall(SqlParserPos.ZERO, id);
+            final SqlValidator validator = bb.getValidator();
+            final RelDataType measureType = validator.getValidatedNodeType(id);
+            final RelDataTypeFactory typeFactory = bb.getTypeFactory();
+            final RelDataType valueType = fromMeasure(typeFactory, measureType);
+            validator.setValidatedNodeType(call, valueType);
+            translateAgg(call);
+        }
         return null;
     }
 
@@ -492,6 +505,9 @@ private void translateAgg(
         }
 
         SqlAggFunction aggFunction = (SqlAggFunction) call.getOperator();
+        if (aggFunction == SqlLibraryOperators.AGGREGATE) {
+            aggFunction = SqlInternalOperators.AGG_M2V;
+        }
         final RelDataType type = bb.getValidator().deriveType(bb.scope, call);
         boolean distinct = false;
         SqlLiteral quantifier = call.getFunctionQuantifier();
@@ -505,7 +521,7 @@ private void translateAgg(
             approximate = true;
         }
         final RelCollation collation;
-        if (orderList == null || orderList.size() == 0) {
+        if (orderList == null || orderList.isEmpty()) {
             collation = RelCollations.EMPTY;
         } else {
             try {
@@ -531,6 +547,7 @@ private void translateAgg(
         }
         final AggregateCall aggCall =
                 AggregateCall.create(
+                        call.getParserPosition(),
                         aggFunction,
                         distinct,
                         approximate,
@@ -548,8 +565,16 @@ private void translateAgg(
                         groupExprs.size(),
                         aggCalls,
                         aggCallMapping,
-                        i -> convertedInputExprs.leftList().get(i).getType().isNullable());
+                        i -> convertedInputExprs.left(i).getType().isNullable());
         aggMapping.put(outerCall, rex);
+        if (aggFunction.kind == SqlKind.AGG_M2V
+                && !distinct
+                && filterArg < 0
+                && distinctKeys == null
+                && args.size() == 1) {
+            // Allow "AGG_M2V(m)" to also be accessed via "m"
+            aggMapping.put(outerCall.operand(0), rex);
+        }
     }
 
     private RelFieldCollation sortToFieldCollation(
@@ -587,7 +612,7 @@ int lookupGroupExpr(SqlNode expr) {
     }
 
     boolean isMeasureExpr(SqlNode expr) {
-        return SqlUtil.indexOfDeep(measureExprs, expr, Litmus.IGNORE) >= 0;
+        return SqlUtil.indexOfDeep(getResolved().measureExprList, expr, Litmus.IGNORE) >= 0;
     }
 
     @Nullable RexNode lookupMeasure(SqlNode expr) {
@@ -605,7 +630,7 @@ boolean isMeasureExpr(SqlNode expr) {
                 final int groupOrdinal = e.getValue().i;
                 return converter.convert(
                         rexBuilder,
-                        convertedInputExprs.leftList().get(groupOrdinal),
+                        convertedInputExprs.left(groupOrdinal),
                         rexBuilder.makeInputRef(castNonNull(bb.root), groupOrdinal));
             }
         }
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
index 212daeadc7407..e3237b4b42aad 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
@@ -433,14 +433,20 @@ protected RexNode removeCorrelationExpr(
                         projectPulledAboveLeftCorrelator,
                         null,
                         isCount);
-        return exp.accept(shuttle);
+        RexNode exp2 = exp.accept(shuttle);
+
+        // Fix the nullability.
+        if (projectPulledAboveLeftCorrelator) {
+            exp2 = relBuilder.getRexBuilder().makeNullable(exp2);
+        }
+        return exp2;
     }
 
     /** Fallback if none of the other {@code decorrelateRel} methods match. */
     public @Nullable Frame decorrelateRel(RelNode rel, boolean isCorVarDefined) {
         RelNode newRel = rel.copy(rel.getTraitSet(), rel.getInputs());
 
-        if (rel.getInputs().size() > 0) {
+        if (!rel.getInputs().isEmpty()) {
             List<RelNode> oldInputs = rel.getInputs();
             List<RelNode> newInputs = new ArrayList<>();
             for (int i = 0; i < oldInputs.size(); ++i) {
@@ -585,11 +591,17 @@ protected RexNode removeCorrelationExpr(
             // Now add the corVars from the input, starting from
             // position oldGroupKeyCount.
             for (Map.Entry<CorDef, Integer> entry : frame.corDefOutputs.entrySet()) {
-                RexInputRef.add2(projects, entry.getValue(), newInputOutput);
-
-                corDefOutputs.put(entry.getKey(), newPos);
-                mapNewInputToProjOutputs.put(entry.getValue(), newPos);
-                newPos++;
+                // Verify if the CorDef position was already added to the mapNewInputToProjOutputs
+                // during the previous group key processing
+                final Integer pos = mapNewInputToProjOutputs.get(entry.getValue());
+                if (pos == null) {
+                    RexInputRef.add2(projects, entry.getValue(), newInputOutput);
+                    corDefOutputs.put(entry.getKey(), newPos);
+                    mapNewInputToProjOutputs.put(entry.getValue(), newPos);
+                    newPos++;
+                } else {
+                    corDefOutputs.put(entry.getKey(), pos);
+                }
             }
         }
 
@@ -603,8 +615,6 @@ protected RexNode removeCorrelationExpr(
             }
         }
 
-        assert newPos == newInputOutput.size();
-
         // This Project will be what the old input maps to,
         // replacing any previous mapping from old input).
         RelNode newProject =
@@ -849,10 +859,8 @@ private static void shiftMapping(Map<Integer, Integer> mapping, int startIndex,
         for (CorRef corVar : correlations) {
             final int oldCorVarOffset = corVar.field;
 
-            final RelNode oldInput = getCorRel(corVar);
-            assert oldInput != null;
-            final Frame frame = getOrCreateFrame(oldInput);
-            assert frame != null;
+            final RelNode oldInput = requireNonNull(getCorRel(corVar));
+            final Frame frame = requireNonNull(getOrCreateFrame(oldInput));
             final RelNode newInput = frame.r;
 
             final List<Integer> newLocalOutputs;
@@ -882,10 +890,8 @@ private static void shiftMapping(Map<Integer, Integer> mapping, int startIndex,
 
         RelNode r = null;
         for (CorRef corVar : correlations) {
-            final RelNode oldInput = getCorRel(corVar);
-            assert oldInput != null;
-            final RelNode newInput = getOrCreateFrame(oldInput).r;
-            assert newInput != null;
+            final RelNode oldInput = requireNonNull(getCorRel(corVar));
+            final RelNode newInput = requireNonNull(getOrCreateFrame(oldInput).r);
 
             if (!joinedInputs.contains(newInput)) {
                 final List<Integer> positions =
@@ -927,11 +933,9 @@ private static void shiftMapping(Map<Integer, Integer> mapping, int startIndex,
         for (CorRef corRef : correlations) {
             // The first input of a Correlate is always the rel defining
             // the correlated variables.
-            final RelNode oldInput = getCorRel(corRef);
-            assert oldInput != null;
+            final RelNode oldInput = requireNonNull(getCorRel(corRef));
             final Frame frame = getOrCreateFrame(oldInput);
-            final RelNode newInput = frame.r;
-            assert newInput != null;
+            final RelNode newInput = requireNonNull(frame.r);
 
             final List<Integer> newLocalOutputs =
                     requireNonNull(
@@ -1389,7 +1393,7 @@ private static boolean isWidening(RelDataType type, RelDataType type1) {
 
     private static RexInputRef getNewForOldInputRef(
             RelNode currentRel, Map<RelNode, Frame> map, RexInputRef oldInputRef) {
-        assert currentRel != null;
+        requireNonNull(currentRel, "currentRel");
 
         int oldOrdinal = oldInputRef.getIndex();
         int newOrdinal = 0;
@@ -1412,10 +1416,8 @@ private static RexInputRef getNewForOldInputRef(
             oldOrdinal -= n;
         }
 
-        assert oldInput != null;
-
-        final Frame frame = map.get(oldInput);
-        assert frame != null;
+        requireNonNull(oldInput, "oldInput");
+        final Frame frame = requireNonNull(map.get(oldInput));
 
         // now oldOrdinal is relative to oldInput
         int oldLocalOrdinal = oldOrdinal;
@@ -1474,7 +1476,6 @@ private RelNode projectJoinOutputWithNullability(
             RexNode newProjExpr =
                     removeCorrelationExpr(
                             pair.left, projectPulledAboveLeftCorrelator, nullIndicator);
-
             newProjExprs.add(newProjExpr, pair.right);
         }
 
@@ -1542,7 +1543,7 @@ private boolean checkCorVars(
             @Nullable Filter filter,
             @Nullable List<RexFieldAccess> correlatedJoinKeys) {
         if (filter != null) {
-            assert correlatedJoinKeys != null;
+            requireNonNull(correlatedJoinKeys, "correlatedJoinKeys");
 
             // check that all correlated refs in the filter condition are
             // used in the join(as field access).
@@ -1863,7 +1864,9 @@ public RexNode visitCall(final RexCall call) {
                     // and preferably in the base class RexShuttle.
                     newType = call.getType();
                 }
-                newCall = rexBuilder.makeCall(newType, operator, clonedOperands);
+                newCall =
+                        rexBuilder.makeCall(
+                                call.getParserPosition(), newType, operator, clonedOperands);
             } else {
                 newCall = call;
             }
@@ -2076,7 +2079,7 @@ public void onMatch(RelOptRuleCall call) {
                 right = right.stripped();
 
                 // check filter input contains no correlation
-                if (RelOptUtil.getVariablesUsed(right).size() > 0) {
+                if (!RelOptUtil.getVariablesUsed(right).isEmpty()) {
                     return;
                 }
 
@@ -2138,7 +2141,7 @@ public void onMatch(RelOptRuleCall call) {
                         left.getRowType().getFieldCount() + rightJoinKeys.get(0).getIndex();
             } else if (d.cm.mapRefRelToCorRef.containsKey(project)) {
                 // check filter input contains no correlation
-                if (RelOptUtil.getVariablesUsed(right).size() > 0) {
+                if (!RelOptUtil.getVariablesUsed(right).isEmpty()) {
                     return;
                 }
 
@@ -2301,8 +2304,8 @@ public void onMatch(RelOptRuleCall call) {
             int k = -1;
             for (AggregateCall aggCall : aggCalls) {
                 ++k;
-                if ((aggCall.getAggregation() instanceof SqlCountAggFunction)
-                        && (aggCall.getArgList().size() == 0)) {
+                if (aggCall.getAggregation() instanceof SqlCountAggFunction
+                        && aggCall.getArgList().isEmpty()) {
                     isCountStar.add(k);
                 }
             }
@@ -2319,7 +2322,7 @@ public void onMatch(RelOptRuleCall call) {
                 right = right.stripped();
 
                 // check filter input contains no correlation
-                if (RelOptUtil.getVariablesUsed(right).size() > 0) {
+                if (!RelOptUtil.getVariablesUsed(right).isEmpty()) {
                     return;
                 }
 
@@ -2415,7 +2418,7 @@ public void onMatch(RelOptRuleCall call) {
                 joinCond = d.removeCorrelationExpr(filter.getCondition(), false);
             } else if (d.cm.mapRefRelToCorRef.containsKey(aggInputProject)) {
                 // check rightInput contains no correlation
-                if (RelOptUtil.getVariablesUsed(right).size() > 0) {
+                if (!RelOptUtil.getVariablesUsed(right).isEmpty()) {
                     return;
                 }
 
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
index 2b9589203dbc9..d4d0dda74e70f 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
@@ -26,6 +26,7 @@
 import org.apache.flink.table.planner.plan.utils.FlinkRelOptUtil;
 import org.apache.flink.table.planner.utils.ShortcutUtils;
 
+import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
@@ -106,6 +107,7 @@
 import org.apache.calcite.rex.RexUtil;
 import org.apache.calcite.rex.RexWindowBound;
 import org.apache.calcite.rex.RexWindowBounds;
+import org.apache.calcite.rex.RexWindowExclusion;
 import org.apache.calcite.runtime.PairList;
 import org.apache.calcite.schema.ColumnStrategy;
 import org.apache.calcite.schema.ModifiableTable;
@@ -118,6 +120,7 @@
 import org.apache.calcite.sql.JoinConditionType;
 import org.apache.calcite.sql.JoinType;
 import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.SqlAsofJoin;
 import org.apache.calcite.sql.SqlBasicCall;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlCallBinding;
@@ -159,13 +162,13 @@
 import org.apache.calcite.sql.SqlWithItem;
 import org.apache.calcite.sql.fun.SqlCase;
 import org.apache.calcite.sql.fun.SqlInOperator;
+import org.apache.calcite.sql.fun.SqlInternalOperators;
 import org.apache.calcite.sql.fun.SqlQuantifyOperator;
 import org.apache.calcite.sql.fun.SqlRowOperator;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.type.TableFunctionReturnTypeInference;
 import org.apache.calcite.sql.util.SqlBasicVisitor;
 import org.apache.calcite.sql.util.SqlVisitor;
@@ -174,6 +177,7 @@
 import org.apache.calcite.sql.validate.DelegatingScope;
 import org.apache.calcite.sql.validate.ListScope;
 import org.apache.calcite.sql.validate.MatchRecognizeScope;
+import org.apache.calcite.sql.validate.MeasureScope;
 import org.apache.calcite.sql.validate.ParameterScope;
 import org.apache.calcite.sql.validate.SelectScope;
 import org.apache.calcite.sql.validate.SqlLambdaScope;
@@ -189,6 +193,8 @@
 import org.apache.calcite.sql.validate.SqlValidatorTable;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
 import org.apache.calcite.sql.validate.SqlWithItemTableRef;
+import org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard;
+import org.apache.calcite.sql2rel.SqlToRelConverter.SqlIdentifierFinder;
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.tools.RelBuilderFactory;
 import org.apache.calcite.util.ImmutableBitSet;
@@ -236,8 +242,15 @@
 import static org.apache.calcite.sql.SqlUtil.containsDefault;
 import static org.apache.calcite.sql.SqlUtil.containsIn;
 import static org.apache.calcite.sql.SqlUtil.stripAs;
+import static org.apache.calcite.sql.type.SqlTypeUtil.equalSansNullability;
+import static org.apache.calcite.sql.type.SqlTypeUtil.fromMeasure;
+import static org.apache.calcite.sql.type.SqlTypeUtil.hasScale;
+import static org.apache.calcite.sql.type.SqlTypeUtil.isApproximateNumeric;
+import static org.apache.calcite.sql.type.SqlTypeUtil.isExactNumeric;
+import static org.apache.calcite.sql.type.SqlTypeUtil.keepSourceTypeAndTargetNullability;
+import static org.apache.calcite.sql.type.SqlTypeUtil.promoteToRowType;
 import static org.apache.calcite.util.Static.RESOURCE;
-import static org.apache.flink.util.Preconditions.checkNotNull;
+import static org.apache.calcite.util.Util.transform;
 
 /**
  * Converts a SQL parse tree (consisting of {@link org.apache.calcite.sql.SqlNode} objects) into a
@@ -416,10 +429,7 @@ private SqlValidator validator() {
     }
 
     private <T extends SqlValidatorNamespace> T getNamespace(SqlNode node) {
-        //noinspection unchecked
-        return (T)
-                requireNonNull(
-                        getNamespaceOrNull(node), () -> "Namespace is not found for " + node);
+        return requireNonNull(getNamespaceOrNull(node), () -> "Namespace is not found for " + node);
     }
 
     @SuppressWarnings("unchecked")
@@ -514,7 +524,7 @@ public void setDynamicParamCountInExplain(int explainParamCount) {
         this.explainParamCount = explainParamCount;
     }
 
-    private void checkConvertedType(SqlNode query, RelNode result) {
+    private void checkConvertedType(SqlNode query, RelNode result, boolean unwrapMeasures) {
         if (query.isA(SqlKind.DML)) {
             return;
         }
@@ -529,7 +539,11 @@ private void checkConvertedType(SqlNode query, RelNode result) {
                 validator()
                         .getTypeFactory()
                         .createStructType(
-                                Pair.right(validatedFields),
+                                transform(
+                                        validatedFields,
+                                        unwrapMeasures
+                                                ? f -> fromMeasure(typeFactory, f.getType())
+                                                : RelDataTypeField::getType),
                                 SqlValidatorUtil.uniquify(
                                         Pair.left(validatedFields),
                                         catalogReader.nameMatcher().isCaseSensitive()));
@@ -580,7 +594,7 @@ public RelNode decorrelate(SqlNode query, RelNode rootRel) {
         }
         final RelNode result = decorrelateQuery(rootRel);
         if (result != rootRel) {
-            checkConvertedType(query, result);
+            checkConvertedType(query, result, false);
         }
         return result;
     }
@@ -648,12 +662,16 @@ protected RelFieldTrimmer newFieldTrimmer() {
      *     <code>false</code> if the query will be part of a view.
      */
     public RelRoot convertQuery(SqlNode query, final boolean needsValidation, final boolean top) {
+        final boolean unwrapMeasures = !validator().config().embeddedQuery();
         if (needsValidation) {
             query = validator().validate(query);
         }
 
         RelNode result = convertQueryRecursive(query, top, null).rel;
         if (top) {
+            if (unwrapMeasures) {
+                result = unwrapMeasures(result);
+            }
             if (isStream(query)) {
                 result = new LogicalDelta(cluster, result.getTraitSet(), result);
             }
@@ -664,7 +682,7 @@ public RelRoot convertQuery(SqlNode query, final boolean needsValidation, final
                 collation = requiredCollation(result);
             }
         }
-        checkConvertedType(query, result);
+        checkConvertedType(query, result, top && unwrapMeasures);
 
         if (SQL2REL_LOGGER.isDebugEnabled()) {
             SQL2REL_LOGGER.debug(
@@ -712,6 +730,28 @@ public RelRoot convertQuery(SqlNode query, final boolean needsValidation, final
                 .withHints(hints);
     }
 
+    /**
+     * If any of the fields of {@code r} are measures, wraps them in calls to the {@code M2V}
+     * function.
+     */
+    private RelNode unwrapMeasures(RelNode r) {
+        if (r.getRowType().getFieldList().stream().anyMatch(f -> f.getType().isMeasure())) {
+            return relBuilder
+                    .push(r)
+                    .project(
+                            relBuilder.fields().stream()
+                                    .map(this::measureToValue)
+                                    .collect(toImmutableList()),
+                            relBuilder.peek().getRowType().getFieldNames())
+                    .build();
+        }
+        return r;
+    }
+
+    private RexNode measureToValue(RexNode e) {
+        return e.getType().isMeasure() ? relBuilder.call(SqlInternalOperators.M2V, e) : e;
+    }
+
     private static boolean isStream(SqlNode query) {
         return query instanceof SqlSelect
                 && ((SqlSelect) query).isKeywordPresent(SqlSelectKeyword.STREAM);
@@ -721,11 +761,11 @@ public static boolean isOrdered(SqlNode query) {
         switch (query.getKind()) {
             case SELECT:
                 SqlNodeList orderList = ((SqlSelect) query).getOrderList();
-                return orderList != null && orderList.size() > 0;
+                return orderList != null && !orderList.isEmpty();
             case WITH:
                 return isOrdered(((SqlWith) query).body);
             case ORDER_BY:
-                return ((SqlOrderBy) query).orderList.size() > 0;
+                return !((SqlOrderBy) query).orderList.isEmpty();
             default:
                 return false;
         }
@@ -747,8 +787,10 @@ private static RelCollation requiredCollation(RelNode r) {
     /** Converts a SELECT statement's parse tree into a relational expression. */
     public RelNode convertSelect(SqlSelect select, boolean top) {
         final SqlValidatorScope selectScope = validator().getWhereScope(select);
+        final MeasureScope measureScope = (MeasureScope) validator().getMeasureScope(select);
         final Blackboard bb = createBlackboard(selectScope, null, top);
-        convertSelectImpl(bb, select);
+        final Blackboard measureBb = new MeasureBlackboard(measureScope, bb);
+        convertSelectImpl(bb, measureBb, select);
         return castNonNull(bb.root);
     }
 
@@ -759,7 +801,8 @@ protected Blackboard createBlackboard(
     }
 
     /** Implementation of {@link #convertSelect(SqlSelect, boolean)}; derived class may override. */
-    protected void convertSelectImpl(final Blackboard bb, SqlSelect select) {
+    protected void convertSelectImpl(
+            final Blackboard bb, final Blackboard measureBb, SqlSelect select) {
         convertFrom(bb, select.getFrom());
 
         // We would like to remove ORDER BY clause from an expanded view, except if
@@ -806,7 +849,7 @@ protected void convertSelectImpl(final Blackboard bb, SqlSelect select) {
         if (validator().isAggregate(select)) {
             convertAgg(bb, select, orderExprList);
         } else {
-            convertSelectList(bb, select, orderExprList);
+            convertSelectList(bb, measureBb, select, orderExprList);
         }
 
         convertQualify(bb, select.getQualify());
@@ -860,7 +903,10 @@ private void distinctify(Blackboard bb, boolean checkForDupExprs) {
         // Say we have 'select x, y, x, z'.
         // Then dups will be {[2, 0]}
         // and oldToNew will be {[0, 0], [1, 1], [2, 0], [3, 2]}
-        RelNode rel = bb.root;
+        if (bb.root == null) {
+            throw new IllegalArgumentException("rel must not be null");
+        }
+        final RelNode rel = bb.root;
         if (checkForDupExprs && (rel instanceof LogicalProject)) {
             LogicalProject project = (LogicalProject) rel;
             final List<RexNode> projectExprs = project.getProjects();
@@ -889,16 +935,15 @@ private void distinctify(Blackboard bb, boolean checkForDupExprs) {
                     RexInputRef.add2(newProjects, i, fields);
                 }
             }
-            rel =
+            bb.root =
                     LogicalProject.create(
                             rel,
                             ImmutableList.of(),
                             newProjects.leftList(),
                             newProjects.rightList(),
                             project.getVariablesSet());
-            bb.root = rel;
             distinctify(bb, false);
-            rel = bb.root();
+            final RelNode rel3 = bb.root();
 
             // Create the expressions to reverse the mapping.
             // Project($0, $1, $0, $2).
@@ -911,24 +956,23 @@ private void distinctify(Blackboard bb, boolean checkForDupExprs) {
                         field.getName());
             }
 
-            rel =
+            bb.setRoot(
                     LogicalProject.create(
-                            rel,
+                            rel3,
                             ImmutableList.of(),
                             undoProjects.leftList(),
                             undoProjects.rightList(),
-                            ImmutableSet.of());
-            bb.setRoot(rel, false);
+                            ImmutableSet.of()),
+                    false);
 
             return;
         }
 
-        assert rel != null : "rel must not be null, root = " + bb.root;
         // Usual case: all expressions in the SELECT clause are different.
         final ImmutableBitSet groupSet = ImmutableBitSet.range(rel.getRowType().getFieldCount());
-        rel = createAggregate(bb, groupSet, ImmutableList.of(groupSet), ImmutableList.of());
-
-        bb.setRoot(rel, false);
+        bb.setRoot(
+                createAggregate(bb, groupSet, ImmutableList.of(groupSet), ImmutableList.of()),
+                false);
     }
 
     /**
@@ -980,7 +1024,7 @@ protected void convertOrder(
         // we can't represent the real collation.
         //
         // If it is the top node, use the real collation, but don't trim fields.
-        if (orderExprList.size() > 0 && !bb.top) {
+        if (!orderExprList.isEmpty() && !bb.top) {
             final List<RexNode> exprs = new ArrayList<>();
             final RelDataType rowType = bb.root().getRowType();
             final int fieldCount = rowType.getFieldCount() - orderExprList.size();
@@ -1047,7 +1091,7 @@ private static SqlNode pushDownNotForIn(SqlValidatorScope scope, SqlNode sqlNode
                         SqlNode elseOperand =
                                 requireNonNull(
                                         caseNode.getElseOperand(),
-                                        "getElseOperand for " + caseNode);
+                                        () -> "getElseOperand for " + caseNode);
                         if (!SqlUtil.isNull(elseOperand)) {
                             // "not(unknown)" is "unknown", so no need to simplify
                             final SqlCall not =
@@ -1220,16 +1264,14 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
                 }
                 final SqlNode leftKeyNode = call.operand(0);
 
-                final List<RexNode> leftKeys;
+                final List<SqlNode> leftSqlKeys;
                 switch (leftKeyNode.getKind()) {
                     case ROW:
-                        leftKeys = new ArrayList<>();
-                        for (SqlNode sqlExpr : ((SqlBasicCall) leftKeyNode).getOperandList()) {
-                            leftKeys.add(bb.convertExpression(sqlExpr));
-                        }
+                        leftSqlKeys =
+                                new ArrayList<>(((SqlBasicCall) leftKeyNode).getOperandList());
                         break;
                     default:
-                        leftKeys = ImmutableList.of(bb.convertExpression(leftKeyNode));
+                        leftSqlKeys = ImmutableList.of(leftKeyNode);
                 }
 
                 if (query instanceof SqlNodeList) {
@@ -1241,7 +1283,7 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
                         subQuery.expr =
                                 convertInToOr(
                                         bb,
-                                        leftKeys,
+                                        leftSqlKeys,
                                         valueList,
                                         (SqlInOperator) call.getOperator());
                         return;
@@ -1252,6 +1294,9 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
                     // reference to Q below.
                 }
 
+                final List<RexNode> leftKeys =
+                        leftSqlKeys.stream().map(bb::convertExpression).collect(toImmutableList());
+
                 // Project out the search columns from the left side
 
                 // Q1:
@@ -1286,7 +1331,7 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
                     return;
                 }
                 final RelDataType targetRowType =
-                        SqlTypeUtil.promoteToRowType(
+                        promoteToRowType(
                                 typeFactory, validator().getValidatedNodeType(leftKeyNode), null);
                 final boolean notIn = call.getOperator().kind == SqlKind.NOT_IN;
                 converted =
@@ -1312,6 +1357,7 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
                                     null,
                                     ImmutableList.of(
                                             AggregateCall.create(
+                                                    call.getParserPosition(),
                                                     SqlStdOperatorTable.COUNT,
                                                     false,
                                                     false,
@@ -1324,6 +1370,7 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
                                                     longType,
                                                     null),
                                             AggregateCall.create(
+                                                    call.getParserPosition(),
                                                     SqlStdOperatorTable.COUNT,
                                                     false,
                                                     false,
@@ -1746,7 +1793,7 @@ public RelNode convertToSingleValueSubq(SqlNode query, RelNode plan) {
             SqlNodeList selectList = select.getSelectList();
             SqlNodeList groupList = select.getGroup();
 
-            if ((selectList.size() == 1) && ((groupList == null) || (groupList.size() == 0))) {
+            if (selectList.size() == 1 && (groupList == null || groupList.isEmpty())) {
                 SqlNode selectExpr = selectList.get(0);
                 if (selectExpr instanceof SqlCall) {
                     SqlCall selectExprCall = (SqlCall) selectExpr;
@@ -1790,12 +1837,11 @@ public RelNode convertToSingleValueSubq(SqlNode query, RelNode plan) {
      */
     private @Nullable RexNode convertInToOr(
             final Blackboard bb,
-            final List<RexNode> leftKeys,
+            final List<SqlNode> leftKeys,
             SqlNodeList valuesList,
             SqlInOperator op) {
         final List<RexNode> comparisons = new ArrayList<>();
         for (SqlNode rightVals : valuesList) {
-            RexNode rexComparison;
             final SqlOperator comparisonOp;
             if (op instanceof SqlQuantifyOperator) {
                 comparisonOp =
@@ -1805,14 +1851,12 @@ public RelNode convertToSingleValueSubq(SqlNode query, RelNode plan) {
             } else {
                 comparisonOp = SqlStdOperatorTable.EQUALS;
             }
+            RexNode rexComparison;
             if (leftKeys.size() == 1) {
-                rexComparison =
-                        rexBuilder.makeCall(
-                                comparisonOp,
-                                leftKeys.get(0),
-                                ensureSqlType(
-                                        leftKeys.get(0).getType(),
-                                        bb.convertExpression(rightVals)));
+                SqlCall sqlCall =
+                        comparisonOp.createCall(
+                                rightVals.getParserPosition(), leftKeys.get(0), rightVals);
+                rexComparison = ensureComparisonTypes(bb.convertExpression(sqlCall));
             } else {
                 assert rightVals instanceof SqlCall;
                 final SqlBasicCall call = (SqlBasicCall) rightVals;
@@ -1821,20 +1865,15 @@ public RelNode convertToSingleValueSubq(SqlNode query, RelNode plan) {
                 rexComparison =
                         RexUtil.composeConjunction(
                                 rexBuilder,
-                                Util.transform(
+                                transform(
                                         Pair.zip(leftKeys, call.getOperandList()),
                                         pair ->
-                                                rexBuilder.makeCall(
-                                                        comparisonOp,
-                                                        pair.left,
-                                                        // TODO: remove requireNonNull when
-                                                        // checkerframework issue resolved
-                                                        ensureSqlType(
-                                                                requireNonNull(
-                                                                                pair.left,
-                                                                                "pair.left")
-                                                                        .getType(),
-                                                                bb.convertExpression(
+                                                ensureComparisonTypes(
+                                                        bb.convertExpression(
+                                                                comparisonOp.createCall(
+                                                                        rightVals
+                                                                                .getParserPosition(),
+                                                                        pair.left,
                                                                         pair.right)))));
             }
             comparisons.add(rexComparison);
@@ -1855,17 +1894,22 @@ public RelNode convertToSingleValueSubq(SqlNode query, RelNode plan) {
         }
     }
 
-    /**
-     * Ensures that an expression has a given {@link SqlTypeName}, applying a cast if necessary. If
-     * the expression already has the right type family, returns the expression unchanged.
-     */
-    private RexNode ensureSqlType(RelDataType type, RexNode node) {
-        if (type.getSqlTypeName() == node.getType().getSqlTypeName()
-                || (type.getSqlTypeName() == SqlTypeName.VARCHAR
-                        && node.getType().getSqlTypeName() == SqlTypeName.CHAR)) {
+    private RexNode ensureComparisonTypes(RexNode node) {
+        if (validator != null && validator.config().typeCoercionEnabled()) {
             return node;
         }
-        return rexBuilder.ensureType(type, node, true);
+        if (node instanceof RexCall) {
+            final RexCall call = (RexCall) node;
+            if (call.operands.size() == 2) {
+                final RexNode left = call.operands.get(0);
+                final RexNode right = call.operands.get(1);
+                if (left.getType().getSqlTypeName() != right.getType().getSqlTypeName()) {
+                    final RexNode castRight = rexBuilder.ensureType(left.getType(), right, true);
+                    return rexBuilder.makeCall(call.getOperator(), left, castRight);
+                }
+            }
+        }
+        return node;
     }
 
     /**
@@ -1942,15 +1986,10 @@ private RelOptUtil.Exists convertExists(
 
         final ImmutableList.Builder<ImmutableList<RexLiteral>> tupleList = ImmutableList.builder();
         final RelDataType listType = validator().getValidatedNodeType(rowList);
-        final RelDataType rowType;
+        RelDataType rowType = promoteToRowType(typeFactory, listType, null);
         if (targetRowType != null) {
-            rowType =
-                    SqlTypeUtil.keepSourceTypeAndTargetNullability(
-                            targetRowType, listType, typeFactory);
-        } else {
-            rowType = SqlTypeUtil.promoteToRowType(typeFactory, listType, null);
+            rowType = keepSourceTypeAndTargetNullability(targetRowType, rowType, typeFactory);
         }
-
         final List<RelNode> unionInputs = new ArrayList<>();
         for (SqlNode node : rows) {
             SqlBasicCall call;
@@ -2034,12 +2073,12 @@ private RexLiteral convertLiteral(SqlLiteral sqlLiteral, Blackboard bb, RelDataT
         }
 
         RexLiteral literal = (RexLiteral) literalExpr;
+        Comparable<?> value = literal.getValue();
 
-        Comparable value = literal.getValue();
-
-        if (SqlTypeUtil.isExactNumeric(type) && SqlTypeUtil.hasScale(type)) {
+        if (value != null && isExactNumeric(type) && hasScale(type)) {
             BigDecimal roundedValue =
-                    NumberUtil.rescaleBigDecimal((BigDecimal) value, type.getScale());
+                    NumberUtil.rescaleBigDecimal(
+                            requireNonNull(literal.getValueAs(BigDecimal.class)), type.getScale());
             return rexBuilder.makeExactLiteral(roundedValue, type);
         }
 
@@ -2341,8 +2380,9 @@ private RexNode convertOver(Blackboard bb, SqlNode node) {
                 // ROW_NUMBER() expects specific kind of framing.
                 rows = true;
             }
-        } else if (orderList.size() == 0) {
-            // Without ORDER BY, there must be no bracketing.
+        } else if (orderList.isEmpty() && !rows) {
+            // In RANGE without ORDER BY, all rows are equivalent, so bracketing has
+            // no effect.
             sqlLowerBound = SqlWindow.createUnboundedPreceding(SqlParserPos.ZERO);
             sqlUpperBound = SqlWindow.createUnboundedFollowing(SqlParserPos.ZERO);
         } else if (sqlLowerBound == null && sqlUpperBound == null) {
@@ -2363,7 +2403,7 @@ private RexNode convertOver(Blackboard bb, SqlNode node) {
                 bb.convertExpression(requireNonNull(sqlLowerBound, "sqlLowerBound"));
         final RexNode upperBound =
                 bb.convertExpression(requireNonNull(sqlUpperBound, "sqlUpperBound"));
-        if (orderList.size() == 0 && !rows) {
+        if (orderList.isEmpty() && !rows) {
             // A logical range requires an ORDER BY clause. Use the implicit
             // ordering of this relation. There must be one, otherwise it would
             // have failed validation.
@@ -2372,6 +2412,7 @@ private RexNode convertOver(Blackboard bb, SqlNode node) {
                 throw new AssertionError("Relation should have sort key for implicit ORDER BY");
             }
         }
+        final RexWindowExclusion exclude = RexWindowExclusion.create(window.getExclude());
 
         final ImmutableList.Builder<RexNode> orderKeys = ImmutableList.builder();
         for (SqlNode order : orderList) {
@@ -2387,7 +2428,12 @@ private RexNode convertOver(Blackboard bb, SqlNode node) {
             checkArgument(bb.window == null, "already in window agg mode");
             bb.window = window;
             RexNode rexAgg = exprConverter.convertCall(bb, aggCall);
-            rexAgg = rexBuilder.ensureType(validator().getValidatedNodeType(call), rexAgg, false);
+            rexAgg =
+                    rexBuilder.ensureType(
+                            call.getParserPosition(),
+                            validator().getValidatedNodeType(call),
+                            rexAgg,
+                            false);
 
             // Walk over the tree and apply 'over' to all agg functions. This is
             // necessary because the returned expression is not necessarily a call
@@ -2403,6 +2449,7 @@ private RexNode convertOver(Blackboard bb, SqlNode node) {
                             rows,
                             RexWindowBounds.create(sqlLowerBound, lowerBound),
                             RexWindowBounds.create(sqlUpperBound, upperBound),
+                            exclude,
                             window.isAllowPartial(),
                             isDistinct,
                             ignoreNulls);
@@ -2650,25 +2697,35 @@ private void convertUnnest(Blackboard bb, SqlCall call, @Nullable List<String> f
                 });
         RelNode child = (null != bb.root) ? bb.root : LogicalValues.createOneRow(cluster);
         RelNode uncollect;
-        if (validator().config().conformance().allowAliasUnnestItems()) {
-            uncollect =
-                    relBuilder
-                            .push(child)
-                            .project(exprs)
-                            .uncollect(
-                                    requireNonNull(fieldNames, "fieldNames"),
-                                    operator.withOrdinality)
-                            .build();
-        } else {
-            // REVIEW danny 2020-04-26: should we unify the normal field aliases and
-            // the item aliases?
-            uncollect =
-                    relBuilder
-                            .push(child)
-                            .project(exprs)
-                            .uncollect(Collections.emptyList(), operator.withOrdinality)
-                            .let(r -> fieldNames == null ? r : r.rename(fieldNames))
-                            .build();
+        try {
+            if (validator().config().conformance().allowAliasUnnestItems()) {
+                uncollect =
+                        relBuilder
+                                .push(child)
+                                .project(exprs)
+                                .uncollect(
+                                        requireNonNull(fieldNames, "fieldNames"),
+                                        operator.withOrdinality)
+                                .build();
+            } else {
+                // REVIEW danny 2020-04-26: should we unify the normal field aliases and
+                // the item aliases?
+                uncollect =
+                        relBuilder
+                                .push(child)
+                                .project(exprs)
+                                .uncollect(Collections.emptyList(), operator.withOrdinality)
+                                .let(r -> fieldNames == null ? r : r.rename(fieldNames))
+                                .build();
+            }
+        } catch (Exception ex) {
+            SqlParserPos pos = call.getParserPosition();
+            throw RESOURCE.validatorContext(
+                            pos.getLineNum(),
+                            pos.getColumnNum(),
+                            pos.getEndLineNum(),
+                            pos.getEndColumnNum())
+                    .ex(ex);
         }
         bb.setRoot(uncollect, true);
     }
@@ -2730,7 +2787,10 @@ public RexNode visit(SqlCall call) {
                             newOperands.add(arg);
                         }
                         return rexBuilder.makeCall(
-                                validator().getUnknownType(), call.getOperator(), newOperands);
+                                call.getParserPosition(),
+                                validator().getUnknownType(),
+                                call.getOperator(),
+                                newOperands);
                     }
 
                     @Override
@@ -2751,7 +2811,9 @@ public RexNode visit(SqlLiteral literal) {
                     }
                 };
         final RexNode patternNode = pattern.accept(patternVarVisitor);
-        assert patternNode != null : "pattern is not found in " + pattern;
+        if (patternNode == null) {
+            throw new AssertionError("pattern is not found in " + pattern);
+        }
 
         SqlLiteral interval = matchRecognize.getInterval();
         RexNode intervalNode = null;
@@ -2778,8 +2840,9 @@ public RexNode visit(SqlLiteral literal) {
 
         final RexNode after;
         if (afterMatch instanceof SqlCall) {
-            List<SqlNode> operands = ((SqlCall) afterMatch).getOperandList();
-            SqlOperator operator = ((SqlCall) afterMatch).getOperator();
+            final SqlCall afterCall = (SqlCall) afterMatch;
+            List<SqlNode> operands = afterCall.getOperandList();
+            SqlOperator operator = afterCall.getOperator();
             assert operands.size() == 1;
             SqlIdentifier id = (SqlIdentifier) operands.get(0);
             assert patternVarsSet.contains(id.getSimple())
@@ -2787,7 +2850,10 @@ public RexNode visit(SqlLiteral literal) {
             RexNode rex = rexBuilder.makeLiteral(id.getSimple());
             after =
                     rexBuilder.makeCall(
-                            validator().getUnknownType(), operator, ImmutableList.of(rex));
+                            afterCall.getParserPosition(),
+                            validator().getUnknownType(),
+                            operator,
+                            ImmutableList.of(rex));
         } else {
             after = matchBb.convertExpression(afterMatch);
         }
@@ -2868,7 +2934,7 @@ protected void convertPivot(Blackboard bb, SqlPivot pivot) {
         // 3. Gather columns used as arguments to aggregate functions.
         pivotBb.agg = aggConverter;
         final List<@Nullable String> aggAliasList = new ArrayList<>();
-        assert aggConverter.aggCalls.size() == 0;
+        assert aggConverter.aggCalls.isEmpty();
         pivot.forEachAgg(
                 (alias, call) -> {
                     call.accept(aggConverter);
@@ -3070,7 +3136,7 @@ protected void convertCollectionTable(Blackboard bb, SqlCall call) {
             TableExpressionFactory expressionFunction =
                     clazz ->
                             Schemas.getTableExpression(
-                                    Objects.requireNonNull(schema, "schema").plus(),
+                                    requireNonNull(schema, "schema").plus(),
                                     Util.last(udf.getNameAsId().names),
                                     table,
                                     clazz);
@@ -3130,7 +3196,7 @@ private void convertTemporalTable(Blackboard bb, SqlCall call) {
             ZoneId zoneId = tableConfig.getLocalTimeZone();
             TimestampString timestampString =
                     ((RexLiteral) period).getValueAs(TimestampString.class);
-            checkNotNull(
+            Preconditions.checkNotNull(
                     timestampString,
                     "The time travel expression %s can not convert to a valid timestamp string. This is a bug. Please file an issue.",
                     period);
@@ -3201,8 +3267,6 @@ protected RelNode createJoin(
             RelNode rightRel,
             RexNode joinCond,
             JoinRelType joinType) {
-        assert joinCond != null;
-
         final CorrelationUse p = getCorrelationUse(bb, rightRel);
         if (p != null) {
             RelNode innerRel = p.r;
@@ -3241,6 +3305,41 @@ protected RelNode createJoin(
         return node;
     }
 
+    protected RelNode createAsofJoin(
+            SqlParserPos pos,
+            Blackboard bb,
+            RelNode leftRel,
+            RelNode rightRel,
+            RexNode joinCond,
+            RexNode matchCondition,
+            JoinRelType joinType) {
+        final CorrelationUse p = getCorrelationUse(bb, rightRel);
+        if (p != null) {
+            // Ideally this should be checked by the validator, but the correlation information
+            // is not know at that point.
+            throw SqlUtil.newContextException(pos, RESOURCE.asofCannotBeCorrelated());
+        }
+
+        final RelNode node =
+                relBuilder
+                        .push(leftRel)
+                        .push(rightRel)
+                        .asofJoin(joinType, joinCond, matchCondition)
+                        .build();
+
+        // If join conditions are pushed down, update the leaves.
+        if (node instanceof Project) {
+            final Join newJoin = (Join) node.getInputs().get(0);
+            if (leaves.containsKey(leftRel)) {
+                leaves.put(newJoin.getLeft(), leaves.get(leftRel));
+            }
+            if (leaves.containsKey(rightRel)) {
+                leaves.put(newJoin.getRight(), leaves.get(rightRel));
+            }
+        }
+        return node;
+    }
+
     private @Nullable CorrelationUse getCorrelationUse(Blackboard bb, final RelNode r0) {
         final Set<CorrelationId> correlatedVariables = RelOptUtil.getVariablesUsed(r0);
         if (correlatedVariables.isEmpty()) {
@@ -3419,6 +3518,7 @@ private void convertJoin(Blackboard bb, SqlJoin join) {
 
         SqlNode left = join.getLeft();
         SqlNode right = join.getRight();
+        JoinType joinType = join.getJoinType();
         final SqlValidatorScope leftScope = validator.getJoinScope(left);
         final Blackboard leftBlackboard = createBlackboard(leftScope, null, false);
         final SqlValidatorScope rightScope = validator.getJoinScope(right);
@@ -3430,7 +3530,7 @@ private void convertJoin(Blackboard bb, SqlJoin join) {
 
         final JoinConditionType conditionType = join.getConditionType();
         final RexNode condition;
-        final RelNode rightRel;
+        RelNode rightRel;
         if (join.isNatural()) {
             condition = convertNaturalCondition(getNamespace(left), getNamespace(right));
             rightRel = tempRightRel;
@@ -3446,8 +3546,11 @@ private void convertJoin(Blackboard bb, SqlJoin join) {
                     rightRel = tempRightRel;
                     break;
                 case ON:
+                    SqlNode sqlCondition =
+                            requireNonNull(
+                                    join.getCondition(), () -> "getCondition for join " + join);
                     Pair<RexNode, RelNode> conditionAndRightNode =
-                            convertOnCondition(fromBlackboard, join, leftRel, tempRightRel);
+                            convertOnCondition(fromBlackboard, sqlCondition, leftRel, tempRightRel);
                     condition = conditionAndRightNode.left;
                     rightRel = conditionAndRightNode.right;
                     break;
@@ -3455,13 +3558,34 @@ private void convertJoin(Blackboard bb, SqlJoin join) {
                     throw Util.unexpected(conditionType);
             }
         }
-        final RelNode joinRel =
-                createJoin(
-                        fromBlackboard,
-                        leftRel,
-                        rightRel,
-                        condition,
-                        convertJoinType(join.getJoinType()));
+        final RelNode joinRel;
+        if (joinType == JoinType.ASOF || joinType == JoinType.LEFT_ASOF) {
+            SqlNode sqlMatchCondition =
+                    requireNonNull(
+                            ((SqlAsofJoin) join).getMatchCondition(),
+                            () -> "getCondition for join " + join);
+            Pair<RexNode, RelNode> conditionAndRightNode =
+                    convertOnCondition(fromBlackboard, sqlMatchCondition, leftRel, tempRightRel);
+            RexNode matchCondition = conditionAndRightNode.left;
+            rightRel = conditionAndRightNode.right;
+            joinRel =
+                    createAsofJoin(
+                            join.getParserPosition(),
+                            fromBlackboard,
+                            leftRel,
+                            rightRel,
+                            condition,
+                            matchCondition,
+                            convertJoinType(joinType));
+        } else {
+            joinRel =
+                    createJoin(
+                            fromBlackboard,
+                            leftRel,
+                            rightRel,
+                            condition,
+                            convertJoinType(joinType));
+        }
         relBuilder.push(joinRel);
         relBuilder.project(relBuilder.fields());
         bb.setRoot(relBuilder.build(), false);
@@ -3524,14 +3648,11 @@ private RexNode convertUsingCondition(
      * However, if the query is joined on the right, side multiplicity is maintained.
      */
     private Pair<RexNode, RelNode> convertOnCondition(
-            Blackboard bb, SqlJoin join, RelNode leftRel, RelNode rightRel) {
-        SqlNode condition =
-                requireNonNull(join.getCondition(), () -> "getCondition for join " + join);
-
+            Blackboard bb, SqlNode condition, RelNode leftRel, RelNode rightRel) {
         bb.setRoot(ImmutableList.of(leftRel, rightRel));
         replaceSubQueries(bb, condition, RelOptUtil.Logic.UNKNOWN_AS_FALSE);
         final RelNode newRightRel =
-                bb.root == null || bb.registered.size() == 0 ? rightRel : bb.reRegister(rightRel);
+                bb.root == null || bb.registered.isEmpty() ? rightRel : bb.reRegister(rightRel);
         bb.setRoot(ImmutableList.of(leftRel, newRightRel));
         RexNode conditionExp = bb.convertExpression(condition);
         if (conditionExp instanceof RexInputRef && newRightRel != rightRel) {
@@ -3568,8 +3689,15 @@ private RexNode convertUsing(
             for (SqlValidatorNamespace n : ImmutableList.of(leftNamespace, rightNamespace)) {
                 final RelDataType rowType = n.getRowType();
                 final RelDataTypeField field = nameMatcher.field(rowType, name);
-                assert field != null
-                        : "field " + name + " is not found in " + rowType + " with " + nameMatcher;
+                if (field == null) {
+                    throw new AssertionError(
+                            "field "
+                                    + name
+                                    + " is not found in "
+                                    + rowType
+                                    + " with "
+                                    + nameMatcher);
+                }
                 operands.add(rexBuilder.makeInputRef(field.getType(), offset + field.getIndex()));
                 offset += rowType.getFieldList().size();
             }
@@ -3590,6 +3718,10 @@ private static JoinRelType convertJoinType(JoinType joinType) {
                 return JoinRelType.LEFT;
             case RIGHT:
                 return JoinRelType.RIGHT;
+            case ASOF:
+                return JoinRelType.ASOF;
+            case LEFT_ASOF:
+                return JoinRelType.LEFT_ASOF;
             default:
                 throw Util.unexpected(joinType);
         }
@@ -3620,7 +3752,7 @@ protected void convertAgg(Blackboard bb, SqlSelect select, List<SqlNode> orderEx
         createAggImpl(bb, aggConverter, selectList, groupList, having, orderExprList);
     }
 
-    protected final void createAggImpl(
+    private void createAggImpl(
             Blackboard bb,
             final AggConverter aggConverter,
             SqlNodeList selectList,
@@ -3701,12 +3833,32 @@ protected final void createAggImpl(
             final RelNode inputRel = bb.root();
 
             // Project the expressions required by agg and having.
-            bb.setRoot(
+            RelNode intermediateProject =
                     relBuilder
                             .push(inputRel)
                             .projectNamed(preExprs.leftList(), preExprs.rightList(), false)
-                            .build(),
-                    false);
+                            .build();
+            final RelNode r2;
+            // deal with correlation
+            final CorrelationUse p = getCorrelationUse(bb, intermediateProject);
+            if (p != null) {
+                assert p.r instanceof Project;
+                // correlation variables have been normalized in p.r, we should use expressions
+                // in p.r instead of the original exprs
+                Project project1 = (Project) p.r;
+                r2 =
+                        relBuilder
+                                .push(bb.root())
+                                .projectNamed(
+                                        project1.getProjects(),
+                                        project1.getRowType().getFieldNames(),
+                                        true,
+                                        ImmutableSet.of(p.id))
+                                .build();
+            } else {
+                r2 = intermediateProject;
+            }
+            bb.setRoot(r2, false);
             bb.mapRootRelToFieldProjection.put(bb.root(), r.groupExprProjection);
 
             // REVIEW jvs 31-Oct-2007:  doesn't the declaration of
@@ -3756,10 +3908,9 @@ protected final void createAggImpl(
             // validator. This is especially the case when there are system
             // fields; system fields appear in the relnode's rowtype but do not
             // (yet) appear in the validator type.
-            final SelectScope selectScope = SqlValidatorUtil.getEnclosingSelectScope(bb.scope);
-            assert selectScope != null;
-            final SqlValidatorNamespace selectNamespace = getNamespaceOrNull(selectScope.getNode());
-            assert selectNamespace != null : "selectNamespace must not be null for " + selectScope;
+            final SelectScope selectScope =
+                    requireNonNull(SqlValidatorUtil.getEnclosingSelectScope(bb.scope));
+            final SqlValidatorNamespace selectNamespace = getNamespace(selectScope.getNode());
             final List<String> names = selectNamespace.getRowType().getFieldNames();
             int sysFieldCount = selectList.size() - names.size();
             for (SqlNode expr : selectList) {
@@ -3779,7 +3930,17 @@ protected final void createAggImpl(
 
         // implement HAVING (we have already checked that it is non-trivial)
         relBuilder.push(bb.root());
-        relBuilder.filter(havingExpr);
+        // Set the correlation variables used in this sub-query to the filter node,
+        // same logic is being used for the filter generated in where clause.
+        Set<CorrelationId> variableSet = new HashSet<>();
+        RexSubQuery subQ = RexUtil.SubQueryFinder.find(havingExpr);
+        if (subQ != null) {
+            CorrelationUse p = getCorrelationUse(bb, subQ.rel);
+            if (p != null) {
+                variableSet.add(p.id);
+            }
+        }
+        relBuilder.filter(variableSet, havingExpr);
 
         // implement the SELECT list
         relBuilder.project(projects.leftList(), projects.rightList()).rename(projects.rightList());
@@ -3852,8 +4013,8 @@ protected void gatherOrderExprs(
             List<SqlNode> extraOrderExprs,
             List<RelFieldCollation> collationList) {
         // TODO:  add validation rules to SqlValidator also
-        assert bb.root != null : "precondition: child != null";
-        assert select != null;
+        requireNonNull(bb.root);
+        requireNonNull(select, "select");
         if (orderList == null) {
             return;
         }
@@ -3887,7 +4048,6 @@ protected RelFieldCollation convertOrderItem(
             List<SqlNode> extraExprs,
             RelFieldCollation.Direction direction,
             RelFieldCollation.NullDirection nullDirection) {
-        assert select != null;
         // Handle DESC keyword, e.g. 'select a, b from t order by a desc'.
         switch (orderItem.getKind()) {
             case DESCENDING:
@@ -3915,12 +4075,11 @@ protected RelFieldCollation convertOrderItem(
                 break;
         }
 
-        SqlNode converted = validator().expandOrderExpr(select, orderItem);
-
+        final SqlValidator validator = validator();
         switch (nullDirection) {
             case UNSPECIFIED:
                 nullDirection =
-                        validator().config().defaultNullCollation().last(desc(direction))
+                        validator.config().defaultNullCollation().last(desc(direction))
                                 ? RelFieldCollation.NullDirection.LAST
                                 : RelFieldCollation.NullDirection.FIRST;
                 break;
@@ -3928,10 +4087,12 @@ protected RelFieldCollation convertOrderItem(
                 break;
         }
 
+        SqlNode converted = validator.expandOrderExpr(select, orderItem);
+
         // Scan the select list and order exprs for an identical expression.
         final SelectScope selectScope =
                 requireNonNull(
-                        validator().getRawSelectScope(select),
+                        validator.getRawSelectScope(select),
                         () -> "getRawSelectScope is not found for " + select);
         int ordinal = -1;
         List<SqlNode> expandedSelectList = selectScope.getExpandedSelectList();
@@ -4073,8 +4234,7 @@ protected RelNode convertInsert(SqlInsert call) {
 
         callStack.push(call);
 
-        final RelDataType targetRowType = validator().getValidatedNodeType(call);
-        assert targetRowType != null;
+        final RelDataType targetRowType = requireNonNull(validator().getValidatedNodeType(call));
         RelNode sourceRel = convertQueryRecursive(call.getSource(), true, targetRowType).project();
         RelNode massagedRel = convertColumnList(call, sourceRel);
 
@@ -4229,7 +4389,7 @@ protected RelOptTable getTargetTable(SqlNode call) {
             namespace = targetNs.resolve();
         }
         RelOptTable table = SqlValidatorUtil.getRelOptTable(namespace, catalogReader, null, null);
-        return requireNonNull(table, "no table found for " + call);
+        return requireNonNull(table, () -> "no table found for " + call);
     }
 
     /**
@@ -4270,7 +4430,9 @@ protected RelNode convertColumnList(final SqlInsert call, RelNode source) {
         final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
         for (Pair<String, RexNode> p : Pair.zip(targetColumnNames, columnExprs)) {
             RelDataTypeField field = nameMatcher.field(targetRowType, p.left);
-            assert field != null : "column " + p.left + " not found";
+            if (field == null) {
+                throw new AssertionError("column " + p.left + " not found");
+            }
             sourceExps.set(field.getIndex(), p.right);
         }
 
@@ -4383,12 +4545,14 @@ protected void collectInsertTargets(
                 targetColumnNames.addAll(tableRowType.getFieldNames());
             }
         } else {
-            for (int i = 0; i < targetColumnList.size(); i++) {
-                SqlIdentifier id = (SqlIdentifier) targetColumnList.get(i);
+            for (SqlNode node : targetColumnList) {
+                SqlIdentifier id = (SqlIdentifier) node;
                 RelDataTypeField field =
                         SqlValidatorUtil.getTargetField(
                                 tableRowType, typeFactory, id, catalogReader, targetTable);
-                assert field != null : "column " + id.toString() + " not found";
+                if (field == null) {
+                    throw new AssertionError("column " + id + " not found");
+                }
                 targetColumnNames.add(field.getName());
             }
         }
@@ -4461,7 +4625,9 @@ private RelNode convertUpdate(SqlUpdate call) {
             RelDataTypeField field =
                     SqlValidatorUtil.getTargetField(
                             targetRowType, typeFactory, id, catalogReader, targetTable);
-            assert field != null : "column " + id + " not found";
+            if (field == null) {
+                throw new AssertionError("column " + id + " not found");
+            }
             targetColumnNameList.add(field.getName());
         }
 
@@ -4492,12 +4658,14 @@ private RelNode convertMerge(SqlMerge call) {
         final RelDataType targetRowType = targetTable.getRowType();
         SqlUpdate updateCall = call.getUpdateCall();
         if (updateCall != null) {
-            for (SqlNode targetColumn : updateCall.getTargetColumnList()) {
-                SqlIdentifier id = (SqlIdentifier) targetColumn;
+            for (SqlNode node : updateCall.getTargetColumnList()) {
+                SqlIdentifier id = (SqlIdentifier) node;
                 RelDataTypeField field =
                         SqlValidatorUtil.getTargetField(
                                 targetRowType, typeFactory, id, catalogReader, targetTable);
-                assert field != null : "column " + id.toString() + " not found";
+                if (field == null) {
+                    throw new AssertionError("column " + id + " not found");
+                }
                 targetColumnNameList.add(field.getName());
             }
         }
@@ -4585,6 +4753,14 @@ private RexNode convertIdentifier(Blackboard bb, SqlIdentifier identifier) {
             pv = identifier.names.get(0);
         }
 
+        final @Nullable SqlNode measure = bb.lookupMeasure(identifier);
+        if (measure != null) {
+            return bb.convertExpression(measure);
+        }
+        if (bb instanceof MeasureBlackboard) {
+            bb = ((MeasureBlackboard) bb).parentBlackboard;
+        }
+
         final SqlQualified qualified = bb.scope.fullyQualify(identifier);
         final Pair<RexNode, @Nullable BiFunction<RexNode, String, RexNode>> e0 =
                 bb.lookupExp(qualified);
@@ -4716,8 +4892,7 @@ private RexFieldAccess adjustRexFieldAccess(RexNode rexNode) {
     protected RexNode adjustInputRef(Blackboard bb, RexInputRef inputRef) {
         RelDataTypeField field = bb.getRootField(inputRef);
         if (field != null) {
-            if (!SqlTypeUtil.equalSansNullability(
-                    typeFactory, field.getType(), inputRef.getType())) {
+            if (!equalSansNullability(typeFactory, field.getType(), inputRef.getType())) {
                 return inputRef;
             }
             return rexBuilder.makeInputRef(field.getType(), inputRef.getIndex());
@@ -4806,7 +4981,7 @@ public SqlNode getNode() {
                     continue;
             }
 
-            if (lastList.size() > 0) {
+            if (!lastList.isEmpty()) {
                 joinList.add(lastList);
             }
             lastList = new ArrayList<>();
@@ -4818,7 +4993,7 @@ public SqlNode getNode() {
             joinList.add(relBuilder.build());
         }
 
-        if (joinList.size() == 0) {
+        if (joinList.isEmpty()) {
             joinList.add(lastList);
         }
 
@@ -4867,7 +5042,8 @@ public SqlNode getNode() {
         return ret;
     }
 
-    private void convertSelectList(Blackboard bb, SqlSelect select, List<SqlNode> orderList) {
+    private void convertSelectList(
+            Blackboard bb, Blackboard measureBb, SqlSelect select, List<SqlNode> orderList) {
         SqlNodeList selectList = select.getSelectList();
         selectList = validator().expandStar(selectList, select, false);
 
@@ -4890,7 +5066,19 @@ private void convertSelectList(Blackboard bb, SqlSelect select, List<SqlNode> or
         int i = -1;
         for (SqlNode expr : selectList) {
             ++i;
-            exprs.add(bb.convertExpression(expr));
+            final SqlNode measure = SqlValidatorUtil.getMeasure(expr);
+            final RexNode e;
+            if (measure != null) {
+                final RexNode m = measureBb.convertExpression(measure);
+                if (m.getType().isMeasure()) {
+                    e = m;
+                } else {
+                    e = rexBuilder.makeCall(SqlInternalOperators.V2M, m);
+                }
+            } else {
+                e = bb.convertExpression(expr);
+            }
+            exprs.add(e);
             fieldNames.add(deriveAlias(expr, aliases, i));
         }
 
@@ -5091,8 +5279,7 @@ public RelRoot convertWith(SqlWith with, boolean top) {
 
     /** Converts a SELECT statement's parse tree into a relational expression. */
     public RelNode convertValues(SqlCall values, @Nullable RelDataType targetRowType) {
-        final SqlValidatorScope scope = validator().getOverScope(values);
-        assert scope != null;
+        final SqlValidatorScope scope = requireNonNull(validator().getOverScope(values));
         final Blackboard bb = createBlackboard(scope, null, false);
         convertValuesImpl(bb, values, targetRowType);
         return bb.root();
@@ -5133,7 +5320,7 @@ private void convertValuesImpl(
 
         if (targetRowType == null) {
             RelDataType listType = validator().getValidatedNodeType(values);
-            targetRowType = SqlTypeUtil.promoteToRowType(typeFactory, listType, null);
+            targetRowType = promoteToRowType(typeFactory, listType, null);
         }
 
         assert insertOp instanceof SqlInsert || !processDefaults : "operation: " + insertOp;
@@ -5571,7 +5758,8 @@ void setRoot(List<RelNode> inputs) {
                             (e, fieldName) -> {
                                 final int j =
                                         requireNonNull(
-                                                fieldMap.get(fieldName), "field " + fieldName);
+                                                fieldMap.get(fieldName),
+                                                () -> "field " + fieldName);
                                 return rexBuilder.makeFieldAccess(e, j);
                             });
                 }
@@ -5671,12 +5859,18 @@ public RexNode convertExpression(SqlNode expr) {
                 if (ref >= 0) {
                     return rexBuilder.makeInputRef(root(), ref);
                 }
+
                 if (expr instanceof SqlCall) {
                     final RexNode rex = agg.lookupAggregates((SqlCall) expr);
                     if (rex != null) {
                         return rex;
                     }
                 }
+
+                final RexNode rex = agg.lookupMeasure(expandedGroupExpr);
+                if (rex != null) {
+                    return rex;
+                }
             }
 
             // Allow the derived class chance to override the standard
@@ -5828,10 +6022,10 @@ public RexNode convertExpression(SqlNode expr) {
                     if (subQuery == null && (kind == SqlKind.SOME || kind == SqlKind.ALL)) {
                         break;
                     }
-                    assert subQuery != null;
+                    requireNonNull(subQuery, "subQuery");
                     rex = requireNonNull(subQuery.expr);
                     return StandardConvertletTable.castToValidatedType(
-                            expr, rex, validator(), rexBuilder, false);
+                            expr.getParserPosition(), expr, rex, validator(), rexBuilder, false);
 
                 case SELECT:
                 case EXISTS:
@@ -5839,10 +6033,8 @@ public RexNode convertExpression(SqlNode expr) {
                 case ARRAY_QUERY_CONSTRUCTOR:
                 case MAP_QUERY_CONSTRUCTOR:
                 case MULTISET_QUERY_CONSTRUCTOR:
-                    subQuery = getSubQuery(expr, null);
-                    assert subQuery != null;
-                    rex = subQuery.expr;
-                    assert rex != null : "rex != null";
+                    subQuery = requireNonNull(getSubQuery(expr, null));
+                    rex = requireNonNull(subQuery.expr);
 
                     if (((kind == SqlKind.SCALAR_QUERY) || (kind == SqlKind.EXISTS))
                             && isConvertedSubq(rex)) {
@@ -6043,8 +6235,7 @@ public SqlNode validateExpression(RelDataType rowType, SqlNode expr) {
 
         @Override
         public RexRangeRef getSubQueryExpr(SqlCall call) {
-            final SubQuery subQuery = getSubQuery(call, null);
-            assert subQuery != null;
+            final SubQuery subQuery = requireNonNull(getSubQuery(call, null));
             return (RexRangeRef) requireNonNull(subQuery.expr, () -> "subQuery.expr for " + call);
         }
 
@@ -6133,6 +6324,10 @@ public RexNode visit(SqlIntervalQualifier intervalQualifier) {
         public List<SqlMonotonicity> getColumnMonotonicities() {
             return columnMonotonicities;
         }
+
+        public @Nullable SqlNode lookupMeasure(SqlIdentifier identifier) {
+            return null;
+        }
     }
 
     private static SqlQuantifyOperator negate(SqlQuantifyOperator operator) {
@@ -6256,6 +6451,7 @@ private class HistogramShuttle extends RexShuttle {
         private final ImmutableList<RexNode> orderKeys;
         private final RexWindowBound lowerBound;
         private final RexWindowBound upperBound;
+        private final RexWindowExclusion exclude;
         private final boolean rows;
         private final boolean allowPartial;
         private final boolean distinct;
@@ -6267,6 +6463,7 @@ private class HistogramShuttle extends RexShuttle {
                 boolean rows,
                 RexWindowBound lowerBound,
                 RexWindowBound upperBound,
+                RexWindowExclusion exclude,
                 boolean allowPartial,
                 boolean distinct,
                 boolean ignoreNulls) {
@@ -6274,6 +6471,7 @@ private class HistogramShuttle extends RexShuttle {
             this.orderKeys = orderKeys;
             this.lowerBound = lowerBound;
             this.upperBound = upperBound;
+            this.exclude = exclude;
             this.rows = rows;
             this.allowPartial = allowPartial;
             this.distinct = distinct;
@@ -6308,15 +6506,20 @@ public RexNode visitCall(RexCall call) {
                             0,
                             reinterpretCast
                                     ? rexBuilder.makeReinterpretCast(
+                                            call.getParserPosition(),
                                             histogramType,
                                             exprs.get(0),
                                             rexBuilder.makeLiteral(false))
-                                    : rexBuilder.makeCast(histogramType, exprs.get(0)));
+                                    : rexBuilder.makeCast(
+                                            call.getParserPosition(), histogramType, exprs.get(0)));
                 }
 
                 RexNode over =
                         relBuilder
-                                .aggregateCall(SqlStdOperatorTable.HISTOGRAM_AGG, exprs)
+                                .aggregateCall(
+                                        call.getParserPosition(),
+                                        SqlStdOperatorTable.HISTOGRAM_AGG,
+                                        exprs)
                                 .distinct(distinct)
                                 .ignoreNulls(ignoreNulls)
                                 .over()
@@ -6327,11 +6530,16 @@ public RexNode visitCall(RexCall call) {
                                                 rows
                                                         ? c.rowsBetween(lowerBound, upperBound)
                                                         : c.rangeBetween(lowerBound, upperBound))
+                                .exclude(exclude)
                                 .allowPartial(allowPartial)
                                 .toRex();
 
                 RexNode histogramCall =
-                        rexBuilder.makeCall(histogramType, histogramOp, ImmutableList.of(over));
+                        rexBuilder.makeCall(
+                                call.getParserPosition(),
+                                histogramType,
+                                histogramOp,
+                                ImmutableList.of(over));
 
                 // If needed, post Cast result back to original
                 // type.
@@ -6339,18 +6547,21 @@ public RexNode visitCall(RexCall call) {
                     if (reinterpretCast) {
                         histogramCall =
                                 rexBuilder.makeReinterpretCast(
-                                        type, histogramCall, rexBuilder.makeLiteral(false));
+                                        call.getParserPosition(),
+                                        type,
+                                        histogramCall,
+                                        rexBuilder.makeLiteral(false));
                     } else {
-                        histogramCall = rexBuilder.makeCast(type, histogramCall);
+                        histogramCall =
+                                rexBuilder.makeCast(call.getParserPosition(), type, histogramCall);
                     }
                 }
 
                 return histogramCall;
             } else {
-                boolean needSum0 = aggOp == SqlStdOperatorTable.SUM && type.isNullable();
-                SqlAggFunction aggOpToUse = needSum0 ? SqlStdOperatorTable.SUM0 : aggOp;
+                boolean nullWhenCountZero = aggOp == SqlStdOperatorTable.SUM && type.isNullable();
                 return relBuilder
-                        .aggregateCall(aggOpToUse, exprs)
+                        .aggregateCall(call.getParserPosition(), aggOp, exprs)
                         .distinct(distinct)
                         .ignoreNulls(ignoreNulls)
                         .over()
@@ -6361,8 +6572,9 @@ public RexNode visitCall(RexCall call) {
                                         rows
                                                 ? c.rowsBetween(lowerBound, upperBound)
                                                 : c.rangeBetween(lowerBound, upperBound))
+                        .exclude(exclude)
                         .allowPartial(allowPartial)
-                        .nullWhenCountZero(needSum0)
+                        .nullWhenCountZero(nullWhenCountZero)
                         .toRex();
             }
         }
@@ -6396,10 +6608,9 @@ public RexNode visitCall(RexCall call) {
          * approximation to it.
          */
         private RelDataType computeHistogramType(RelDataType type) {
-            if (SqlTypeUtil.isExactNumeric(type) && type.getSqlTypeName() != SqlTypeName.BIGINT) {
+            if (isExactNumeric(type) && type.getSqlTypeName() != SqlTypeName.BIGINT) {
                 return typeFactory.createSqlType(SqlTypeName.BIGINT);
-            } else if (SqlTypeUtil.isApproximateNumeric(type)
-                    && type.getSqlTypeName() != SqlTypeName.DOUBLE) {
+            } else if (isApproximateNumeric(type) && type.getSqlTypeName() != SqlTypeName.DOUBLE) {
                 return typeFactory.createSqlType(SqlTypeName.DOUBLE);
             } else {
                 return type;
@@ -6491,7 +6702,7 @@ public Void visit(SqlCall call) {
                 final SqlNode aggCall = call.getOperandList().get(0);
                 final SqlNodeList distinctList = (SqlNodeList) call.getOperandList().get(1);
                 list.add(aggCall);
-                distinctList.getList().forEach(this.distinctList::add);
+                this.distinctList.addAll(distinctList.getList());
                 return null;
             }
 
@@ -6703,9 +6914,9 @@ private class NestedJsonFunctionRelRewriter extends RelShuttleImpl {
         public RelNode visit(LogicalProject project) {
             final Set<Integer> jsonInputFields = findJsonInputs(project.getInput());
             final Set<Integer> requiredJsonFieldsFromParent =
-                    stack.size() > 0
-                            ? requiredJsonOutputFromParent(stack.getLast())
-                            : Collections.emptySet();
+                    stack.isEmpty()
+                            ? Collections.emptySet()
+                            : requiredJsonOutputFromParent(stack.getLast());
 
             final List<RexNode> originalProjections = project.getProjects();
             final ImmutableList.Builder<RexNode> newProjections = ImmutableList.builder();
@@ -6782,7 +6993,8 @@ public RexNode visitCall(RexCall call) {
                         builder.add(call.operands.get(i));
                     }
                 }
-                return rexBuilder.makeCall(SqlStdOperatorTable.JSON_OBJECT, builder.build());
+                return rexBuilder.makeCall(
+                        call.getParserPosition(), SqlStdOperatorTable.JSON_OBJECT, builder.build());
             }
             if (call.getOperator() == SqlStdOperatorTable.JSON_ARRAY) {
                 final ImmutableList.Builder<RexNode> builder = ImmutableList.builder();
@@ -6790,7 +7002,8 @@ public RexNode visitCall(RexCall call) {
                 for (int i = 1; i < call.operands.size(); ++i) {
                     builder.add(forceChildJsonType(call.operands.get(i)));
                 }
-                return rexBuilder.makeCall(SqlStdOperatorTable.JSON_ARRAY, builder.build());
+                return rexBuilder.makeCall(
+                        call.getParserPosition(), SqlStdOperatorTable.JSON_ARRAY, builder.build());
             }
             return super.visitCall(call);
         }
@@ -6817,4 +7030,24 @@ private boolean isJsonResult(RexNode rexNode) {
             return false;
         }
     }
+
+    /** Blackboard for converting measure expressions. */
+    private class MeasureBlackboard extends Blackboard {
+        private final MeasureScope measureScope;
+        private final Blackboard parentBlackboard;
+
+        MeasureBlackboard(MeasureScope measureScope, Blackboard bb) {
+            super(measureScope, bb.nameToNodeMap, bb.top);
+            this.measureScope = measureScope;
+            this.parentBlackboard = bb;
+        }
+
+        @Override
+        public @Nullable SqlNode lookupMeasure(SqlIdentifier identifier) {
+            if (identifier.isSimple()) {
+                return measureScope.lookupMeasure(identifier.getSimple());
+            }
+            return super.lookupMeasure(identifier);
+        }
+    }
 }
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
deleted file mode 100644
index 08f9c4e1bb8b0..0000000000000
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
+++ /dev/null
@@ -1,2183 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.sql2rel;
-
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-import org.apache.calcite.avatica.util.DateTimeUtils;
-import org.apache.calcite.avatica.util.TimeUnit;
-import org.apache.calcite.plan.RelOptUtil;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.calcite.rel.type.RelDataTypeFamily;
-import org.apache.calcite.rel.type.RelDataTypeField;
-import org.apache.calcite.rel.type.TimeFrame;
-import org.apache.calcite.rex.RexBuilder;
-import org.apache.calcite.rex.RexCall;
-import org.apache.calcite.rex.RexCallBinding;
-import org.apache.calcite.rex.RexLiteral;
-import org.apache.calcite.rex.RexNode;
-import org.apache.calcite.rex.RexRangeRef;
-import org.apache.calcite.rex.RexUtil;
-import org.apache.calcite.runtime.SqlFunctions;
-import org.apache.calcite.sql.SqlAggFunction;
-import org.apache.calcite.sql.SqlBasicCall;
-import org.apache.calcite.sql.SqlBinaryOperator;
-import org.apache.calcite.sql.SqlCall;
-import org.apache.calcite.sql.SqlDataTypeSpec;
-import org.apache.calcite.sql.SqlFunction;
-import org.apache.calcite.sql.SqlFunctionCategory;
-import org.apache.calcite.sql.SqlIdentifier;
-import org.apache.calcite.sql.SqlIntervalLiteral;
-import org.apache.calcite.sql.SqlIntervalQualifier;
-import org.apache.calcite.sql.SqlJdbcFunctionCall;
-import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.SqlLiteral;
-import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.SqlNodeList;
-import org.apache.calcite.sql.SqlNumericLiteral;
-import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlOperatorBinding;
-import org.apache.calcite.sql.SqlTableFunction;
-import org.apache.calcite.sql.SqlUtil;
-import org.apache.calcite.sql.SqlWindowTableFunction;
-import org.apache.calcite.sql.fun.SqlArrayValueConstructor;
-import org.apache.calcite.sql.fun.SqlBetweenOperator;
-import org.apache.calcite.sql.fun.SqlCase;
-import org.apache.calcite.sql.fun.SqlCastFunction;
-import org.apache.calcite.sql.fun.SqlDatetimeSubtractionOperator;
-import org.apache.calcite.sql.fun.SqlExtractFunction;
-import org.apache.calcite.sql.fun.SqlInternalOperators;
-import org.apache.calcite.sql.fun.SqlJsonQueryFunction;
-import org.apache.calcite.sql.fun.SqlJsonValueFunction;
-import org.apache.calcite.sql.fun.SqlLibrary;
-import org.apache.calcite.sql.fun.SqlLibraryOperators;
-import org.apache.calcite.sql.fun.SqlLiteralChainOperator;
-import org.apache.calcite.sql.fun.SqlMapValueConstructor;
-import org.apache.calcite.sql.fun.SqlMultisetQueryConstructor;
-import org.apache.calcite.sql.fun.SqlMultisetValueConstructor;
-import org.apache.calcite.sql.fun.SqlOverlapsOperator;
-import org.apache.calcite.sql.fun.SqlRowOperator;
-import org.apache.calcite.sql.fun.SqlSequenceValueOperator;
-import org.apache.calcite.sql.fun.SqlStdOperatorTable;
-import org.apache.calcite.sql.fun.SqlSubstringFunction;
-import org.apache.calcite.sql.fun.SqlTrimFunction;
-import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.type.SqlOperandTypeChecker;
-import org.apache.calcite.sql.type.SqlTypeFamily;
-import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.type.SqlTypeUtil;
-import org.apache.calcite.sql.validate.SqlValidator;
-import org.apache.calcite.util.Pair;
-import org.apache.calcite.util.Util;
-import org.checkerframework.checker.nullness.qual.Nullable;
-
-import java.math.BigDecimal;
-import java.math.RoundingMode;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
-import java.util.stream.Collectors;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static java.util.Objects.requireNonNull;
-import static org.apache.calcite.sql.fun.SqlStdOperatorTable.QUANTIFY_OPERATORS;
-import static org.apache.calcite.sql.type.NonNullableAccessors.getComponentTypeOrThrow;
-import static org.apache.calcite.util.Util.first;
-
-/**
- * Standard implementation of {@link SqlRexConvertletTable}.
- *
- * <p>FLINK modifications are at lines
- *
- * <ol>
- *   <li>Added in Flink-35216: Lines 843 ~ 889
- * </ol>
- */
-public class StandardConvertletTable extends ReflectiveConvertletTable {
-
-    /** Singleton instance. */
-    public static final StandardConvertletTable INSTANCE = new StandardConvertletTable();
-
-    // ~ Constructors -----------------------------------------------------------
-
-    private StandardConvertletTable() {
-        super();
-
-        // Register aliases (operators which have a different name but
-        // identical behavior to other operators).
-        addAlias(SqlLibraryOperators.LEN, SqlStdOperatorTable.CHAR_LENGTH);
-        addAlias(SqlLibraryOperators.LENGTH, SqlStdOperatorTable.CHAR_LENGTH);
-        addAlias(SqlStdOperatorTable.CHARACTER_LENGTH, SqlStdOperatorTable.CHAR_LENGTH);
-        addAlias(SqlStdOperatorTable.IS_UNKNOWN, SqlStdOperatorTable.IS_NULL);
-        addAlias(SqlStdOperatorTable.IS_NOT_UNKNOWN, SqlStdOperatorTable.IS_NOT_NULL);
-        addAlias(SqlLibraryOperators.NULL_SAFE_EQUAL, SqlStdOperatorTable.IS_NOT_DISTINCT_FROM);
-        addAlias(SqlStdOperatorTable.PERCENT_REMAINDER, SqlStdOperatorTable.MOD);
-        addAlias(SqlLibraryOperators.IFNULL, SqlLibraryOperators.NVL);
-        addAlias(SqlLibraryOperators.REGEXP_SUBSTR, SqlLibraryOperators.REGEXP_EXTRACT);
-        addAlias(SqlLibraryOperators.ENDSWITH, SqlLibraryOperators.ENDS_WITH);
-        addAlias(SqlLibraryOperators.STARTSWITH, SqlLibraryOperators.STARTS_WITH);
-        addAlias(SqlLibraryOperators.BITAND_AGG, SqlStdOperatorTable.BIT_AND);
-        addAlias(SqlLibraryOperators.BITOR_AGG, SqlStdOperatorTable.BIT_OR);
-
-        // Register convertlets for specific objects.
-        registerOp(SqlStdOperatorTable.CAST, this::convertCast);
-        registerOp(SqlLibraryOperators.SAFE_CAST, this::convertCast);
-        registerOp(SqlLibraryOperators.TRY_CAST, this::convertCast);
-        registerOp(SqlLibraryOperators.INFIX_CAST, this::convertCast);
-        registerOp(
-                SqlStdOperatorTable.IS_DISTINCT_FROM,
-                (cx, call) -> convertIsDistinctFrom(cx, call, false));
-        registerOp(
-                SqlStdOperatorTable.IS_NOT_DISTINCT_FROM,
-                (cx, call) -> convertIsDistinctFrom(cx, call, true));
-
-        registerOp(SqlStdOperatorTable.PLUS, this::convertPlus);
-
-        registerOp(
-                SqlStdOperatorTable.MINUS,
-                (cx, call) -> {
-                    final RexCall e = (RexCall) StandardConvertletTable.this.convertCall(cx, call);
-                    switch (e.getOperands().get(0).getType().getSqlTypeName()) {
-                        case DATE:
-                        case TIME:
-                        case TIMESTAMP:
-                            return convertDatetimeMinus(cx, SqlStdOperatorTable.MINUS_DATE, call);
-                        default:
-                            return e;
-                    }
-                });
-
-        // DATE(string) is equivalent to CAST(string AS DATE),
-        // but other DATE variants are treated as regular functions.
-        registerOp(
-                SqlLibraryOperators.DATE,
-                (cx, call) -> {
-                    final RexCall e = (RexCall) StandardConvertletTable.this.convertCall(cx, call);
-                    if (e.getOperands().size() == 1
-                            && SqlTypeUtil.isString(e.getOperands().get(0).getType())) {
-                        return cx.getRexBuilder().makeCast(e.type, e.getOperands().get(0));
-                    }
-                    return e;
-                });
-
-        registerOp(SqlLibraryOperators.DATETIME_TRUNC, new TruncConvertlet());
-        registerOp(SqlLibraryOperators.TIMESTAMP_TRUNC, new TruncConvertlet());
-
-        registerOp(SqlLibraryOperators.LTRIM, new TrimConvertlet(SqlTrimFunction.Flag.LEADING));
-        registerOp(SqlLibraryOperators.RTRIM, new TrimConvertlet(SqlTrimFunction.Flag.TRAILING));
-
-        registerOp(SqlLibraryOperators.GREATEST, new GreatestConvertlet());
-        registerOp(SqlLibraryOperators.LEAST, new GreatestConvertlet());
-        registerOp(
-                SqlLibraryOperators.SUBSTR_BIG_QUERY, new SubstrConvertlet(SqlLibrary.BIG_QUERY));
-        registerOp(SqlLibraryOperators.SUBSTR_MYSQL, new SubstrConvertlet(SqlLibrary.MYSQL));
-        registerOp(SqlLibraryOperators.SUBSTR_ORACLE, new SubstrConvertlet(SqlLibrary.ORACLE));
-        registerOp(
-                SqlLibraryOperators.SUBSTR_POSTGRESQL, new SubstrConvertlet(SqlLibrary.POSTGRESQL));
-
-        registerOp(SqlLibraryOperators.DATE_ADD, new TimestampAddConvertlet());
-        registerOp(SqlLibraryOperators.DATE_DIFF, new TimestampDiffConvertlet());
-        registerOp(SqlLibraryOperators.DATE_SUB, new TimestampSubConvertlet());
-        registerOp(SqlLibraryOperators.DATETIME_ADD, new TimestampAddConvertlet());
-        registerOp(SqlLibraryOperators.DATETIME_DIFF, new TimestampDiffConvertlet());
-        registerOp(SqlLibraryOperators.DATETIME_SUB, new TimestampSubConvertlet());
-        registerOp(SqlLibraryOperators.TIME_ADD, new TimestampAddConvertlet());
-        registerOp(SqlLibraryOperators.TIME_DIFF, new TimestampDiffConvertlet());
-        registerOp(SqlLibraryOperators.TIME_SUB, new TimestampSubConvertlet());
-        registerOp(SqlLibraryOperators.TIMESTAMP_ADD2, new TimestampAddConvertlet());
-        registerOp(SqlLibraryOperators.TIMESTAMP_DIFF3, new TimestampDiffConvertlet());
-        registerOp(SqlLibraryOperators.TIMESTAMP_SUB, new TimestampSubConvertlet());
-
-        QUANTIFY_OPERATORS.forEach(
-                operator -> registerOp(operator, StandardConvertletTable::convertQuantifyOperator));
-
-        registerOp(SqlLibraryOperators.NVL, StandardConvertletTable::convertNvl);
-        registerOp(SqlLibraryOperators.DECODE, StandardConvertletTable::convertDecode);
-        registerOp(SqlLibraryOperators.IF, StandardConvertletTable::convertIf);
-
-        // Expand "x NOT LIKE y" into "NOT (x LIKE y)"
-        registerOp(
-                SqlStdOperatorTable.NOT_LIKE,
-                (cx, call) ->
-                        cx.convertExpression(
-                                SqlStdOperatorTable.NOT.createCall(
-                                        SqlParserPos.ZERO,
-                                        SqlStdOperatorTable.LIKE.createCall(
-                                                SqlParserPos.ZERO, call.getOperandList()))));
-
-        // Expand "x NOT ILIKE y" into "NOT (x ILIKE y)"
-        registerOp(
-                SqlLibraryOperators.NOT_ILIKE,
-                (cx, call) ->
-                        cx.convertExpression(
-                                SqlStdOperatorTable.NOT.createCall(
-                                        SqlParserPos.ZERO,
-                                        SqlLibraryOperators.ILIKE.createCall(
-                                                SqlParserPos.ZERO, call.getOperandList()))));
-
-        // Expand "x NOT RLIKE y" into "NOT (x RLIKE y)"
-        registerOp(
-                SqlLibraryOperators.NOT_RLIKE,
-                (cx, call) ->
-                        cx.convertExpression(
-                                SqlStdOperatorTable.NOT.createCall(
-                                        SqlParserPos.ZERO,
-                                        SqlLibraryOperators.RLIKE.createCall(
-                                                SqlParserPos.ZERO, call.getOperandList()))));
-
-        // Expand "x NOT SIMILAR y" into "NOT (x SIMILAR y)"
-        registerOp(
-                SqlStdOperatorTable.NOT_SIMILAR_TO,
-                (cx, call) ->
-                        cx.convertExpression(
-                                SqlStdOperatorTable.NOT.createCall(
-                                        SqlParserPos.ZERO,
-                                        SqlStdOperatorTable.SIMILAR_TO.createCall(
-                                                SqlParserPos.ZERO, call.getOperandList()))));
-
-        // Unary "+" has no effect, so expand "+ x" into "x".
-        registerOp(
-                SqlStdOperatorTable.UNARY_PLUS,
-                (cx, call) -> cx.convertExpression(call.operand(0)));
-
-        // "DOT"
-        registerOp(
-                SqlStdOperatorTable.DOT,
-                (cx, call) ->
-                        cx.getRexBuilder()
-                                .makeFieldAccess(
-                                        cx.convertExpression(call.operand(0)),
-                                        call.operand(1).toString(),
-                                        false));
-        // "ITEM"
-        registerOp(SqlStdOperatorTable.ITEM, this::convertItem);
-        // "AS" has no effect, so expand "x AS id" into "x".
-        registerOp(SqlStdOperatorTable.AS, (cx, call) -> cx.convertExpression(call.operand(0)));
-        registerOp(SqlStdOperatorTable.CONVERT, this::convertCharset);
-        registerOp(SqlStdOperatorTable.TRANSLATE, this::translateCharset);
-        // "SQRT(x)" is equivalent to "POWER(x, .5)"
-        registerOp(
-                SqlStdOperatorTable.SQRT,
-                (cx, call) ->
-                        cx.convertExpression(
-                                SqlStdOperatorTable.POWER.createCall(
-                                        SqlParserPos.ZERO,
-                                        call.operand(0),
-                                        SqlLiteral.createExactNumeric("0.5", SqlParserPos.ZERO))));
-
-        // "STRPOS(string, substring) is equivalent to
-        // "POSITION(substring IN string)"
-        registerOp(
-                SqlLibraryOperators.STRPOS,
-                (cx, call) ->
-                        cx.convertExpression(
-                                SqlStdOperatorTable.POSITION.createCall(
-                                        SqlParserPos.ZERO, call.operand(1), call.operand(0))));
-
-        // "INSTR(string, substring, position, occurrence) is equivalent to
-        // "POSITION(substring, string, position, occurrence)"
-        registerOp(SqlLibraryOperators.INSTR, StandardConvertletTable::convertInstr);
-
-        // REVIEW jvs 24-Apr-2006: This only seems to be working from within a
-        // windowed agg.  I have added an optimizer rule
-        // org.apache.calcite.rel.rules.AggregateReduceFunctionsRule which handles
-        // other cases post-translation.  The reason I did that was to defer the
-        // implementation decision; e.g. we may want to push it down to a foreign
-        // server directly rather than decomposed; decomposition is easier than
-        // recognition.
-
-        // Convert "avg(<expr>)" to "cast(sum(<expr>) / count(<expr>) as
-        // <type>)". We don't need to handle the empty set specially, because
-        // the SUM is already supposed to come out as NULL in cases where the
-        // COUNT is zero, so the null check should take place first and prevent
-        // division by zero. We need the cast because SUM and COUNT may use
-        // different types, say BIGINT.
-        //
-        // Similarly STDDEV_POP and STDDEV_SAMP, VAR_POP and VAR_SAMP.
-        registerOp(SqlStdOperatorTable.AVG, new AvgVarianceConvertlet(SqlKind.AVG));
-        registerOp(SqlStdOperatorTable.STDDEV_POP, new AvgVarianceConvertlet(SqlKind.STDDEV_POP));
-        registerOp(SqlStdOperatorTable.STDDEV_SAMP, new AvgVarianceConvertlet(SqlKind.STDDEV_SAMP));
-        registerOp(SqlStdOperatorTable.STDDEV, new AvgVarianceConvertlet(SqlKind.STDDEV_SAMP));
-        registerOp(SqlStdOperatorTable.VAR_POP, new AvgVarianceConvertlet(SqlKind.VAR_POP));
-        registerOp(SqlStdOperatorTable.VAR_SAMP, new AvgVarianceConvertlet(SqlKind.VAR_SAMP));
-        registerOp(SqlStdOperatorTable.VARIANCE, new AvgVarianceConvertlet(SqlKind.VAR_SAMP));
-        registerOp(SqlStdOperatorTable.COVAR_POP, new RegrCovarianceConvertlet(SqlKind.COVAR_POP));
-        registerOp(
-                SqlStdOperatorTable.COVAR_SAMP, new RegrCovarianceConvertlet(SqlKind.COVAR_SAMP));
-        registerOp(SqlStdOperatorTable.REGR_SXX, new RegrCovarianceConvertlet(SqlKind.REGR_SXX));
-        registerOp(SqlStdOperatorTable.REGR_SYY, new RegrCovarianceConvertlet(SqlKind.REGR_SYY));
-
-        final SqlRexConvertlet floorCeilConvertlet = new FloorCeilConvertlet();
-        registerOp(SqlStdOperatorTable.FLOOR, floorCeilConvertlet);
-        registerOp(SqlStdOperatorTable.CEIL, floorCeilConvertlet);
-        registerOp(SqlStdOperatorTable.TIMESTAMP_ADD, new TimestampAddConvertlet());
-        registerOp(SqlStdOperatorTable.TIMESTAMP_DIFF, new TimestampDiffConvertlet());
-
-        registerOp(SqlStdOperatorTable.INTERVAL, StandardConvertletTable::convertInterval);
-
-        // Convert "element(<expr>)" to "$element_slice(<expr>)", if the
-        // expression is a multiset of scalars.
-        if (false) {
-            registerOp(
-                    SqlStdOperatorTable.ELEMENT,
-                    (cx, call) -> {
-                        assert call.operandCount() == 1;
-                        final SqlNode operand = call.operand(0);
-                        final RelDataType type = cx.getValidator().getValidatedNodeType(operand);
-                        if (!getComponentTypeOrThrow(type).isStruct()) {
-                            return cx.convertExpression(
-                                    SqlStdOperatorTable.ELEMENT_SLICE.createCall(
-                                            SqlParserPos.ZERO, operand));
-                        }
-
-                        // fallback on default behavior
-                        return StandardConvertletTable.this.convertCall(cx, call);
-                    });
-        }
-
-        // Convert "$element_slice(<expr>)" to "element(<expr>).field#0"
-        if (false) {
-            registerOp(
-                    SqlStdOperatorTable.ELEMENT_SLICE,
-                    (cx, call) -> {
-                        assert call.operandCount() == 1;
-                        final SqlNode operand = call.operand(0);
-                        final RexNode expr =
-                                cx.convertExpression(
-                                        SqlStdOperatorTable.ELEMENT.createCall(
-                                                SqlParserPos.ZERO, operand));
-                        return cx.getRexBuilder().makeFieldAccess(expr, 0);
-                    });
-        }
-    }
-
-    /** Converts ALL or SOME operators. */
-    private static RexNode convertQuantifyOperator(SqlRexContext cx, SqlCall call) {
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        final RexNode left = cx.convertExpression(call.getOperandList().get(0));
-        assert call.getOperandList().get(1) instanceof SqlNodeList;
-        final RexNode right =
-                cx.convertExpression(((SqlNodeList) call.getOperandList().get(1)).get(0));
-        final RelDataType rightComponentType = requireNonNull(right.getType().getComponentType());
-        final RelDataType returnType =
-                cx.getTypeFactory()
-                        .createTypeWithNullability(
-                                cx.getTypeFactory().createSqlType(SqlTypeName.BOOLEAN),
-                                right.getType().isNullable()
-                                        || left.getType().isNullable()
-                                        || rightComponentType.isNullable());
-        return rexBuilder.makeCall(returnType, call.getOperator(), ImmutableList.of(left, right));
-    }
-
-    /** Converts a call to the {@code NVL} function (and also its synonym, {@code IFNULL}). */
-    private static RexNode convertNvl(SqlRexContext cx, SqlCall call) {
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        final RexNode operand0 = cx.convertExpression(call.getOperandList().get(0));
-        final RexNode operand1 = cx.convertExpression(call.getOperandList().get(1));
-        final RelDataType type = cx.getValidator().getValidatedNodeType(call);
-        // Preserve Operand Nullability
-        return rexBuilder.makeCall(
-                type,
-                SqlStdOperatorTable.CASE,
-                ImmutableList.of(
-                        rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, operand0),
-                        rexBuilder.makeCast(
-                                cx.getTypeFactory()
-                                        .createTypeWithNullability(
-                                                type, operand0.getType().isNullable()),
-                                operand0),
-                        rexBuilder.makeCast(
-                                cx.getTypeFactory()
-                                        .createTypeWithNullability(
-                                                type, operand1.getType().isNullable()),
-                                operand1)));
-    }
-
-    /**
-     * Converts a call to the INSTR function. INSTR(string, substring, position, occurrence) is
-     * equivalent to POSITION(substring, string, position, occurrence)
-     */
-    private static RexNode convertInstr(SqlRexContext cx, SqlCall call) {
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        final List<RexNode> operands =
-                convertOperands(cx, call, SqlOperandTypeChecker.Consistency.NONE);
-        final RelDataType type = cx.getValidator().getValidatedNodeType(call);
-        final List<RexNode> exprs = new ArrayList<>();
-        switch (call.operandCount()) {
-            // Must reverse order of first 2 operands.
-            case 2:
-                exprs.add(operands.get(1)); // Substring
-                exprs.add(operands.get(0)); // String
-                break;
-            case 3:
-                exprs.add(operands.get(1)); // Substring
-                exprs.add(operands.get(0)); // String
-                exprs.add(operands.get(2)); // Position
-                break;
-            case 4:
-                exprs.add(operands.get(1)); // Substring
-                exprs.add(operands.get(0)); // String
-                exprs.add(operands.get(2)); // Position
-                exprs.add(operands.get(3)); // Occurrence
-                break;
-            default:
-                throw new UnsupportedOperationException(
-                        "Position does not accept " + call.operandCount() + " operands");
-        }
-        return rexBuilder.makeCall(type, SqlStdOperatorTable.POSITION, exprs);
-    }
-
-    /** Converts a call to the DECODE function. */
-    private static RexNode convertDecode(SqlRexContext cx, SqlCall call) {
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        final List<RexNode> operands =
-                convertOperands(cx, call, SqlOperandTypeChecker.Consistency.NONE);
-        final RelDataType type = cx.getValidator().getValidatedNodeType(call);
-        final List<RexNode> exprs = new ArrayList<>();
-        for (int i = 1; i < operands.size() - 1; i += 2) {
-            exprs.add(
-                    RelOptUtil.isDistinctFrom(rexBuilder, operands.get(0), operands.get(i), true));
-            exprs.add(operands.get(i + 1));
-        }
-        if (operands.size() % 2 == 0) {
-            exprs.add(Util.last(operands));
-        } else {
-            exprs.add(rexBuilder.makeNullLiteral(type));
-        }
-        return rexBuilder.makeCall(type, SqlStdOperatorTable.CASE, exprs);
-    }
-
-    /**
-     * Converts a call to the IF function.
-     *
-     * <p>{@code IF(b, x, y)} &rarr; {@code CASE WHEN b THEN x ELSE y END}.
-     */
-    private static RexNode convertIf(SqlRexContext cx, SqlCall call) {
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        final List<RexNode> operands =
-                convertOperands(cx, call, SqlOperandTypeChecker.Consistency.NONE);
-        final RelDataType type = cx.getValidator().getValidatedNodeType(call);
-        return rexBuilder.makeCall(type, SqlStdOperatorTable.CASE, operands);
-    }
-
-    /** Converts an interval expression to a numeric multiplied by an interval literal. */
-    private static RexNode convertInterval(SqlRexContext cx, SqlCall call) {
-        // "INTERVAL n HOUR" becomes "n * INTERVAL '1' HOUR"
-        final SqlNode n = call.operand(0);
-        final SqlIntervalQualifier intervalQualifier = call.operand(1);
-        final SqlIntervalLiteral literal =
-                SqlLiteral.createInterval(1, "1", intervalQualifier, call.getParserPosition());
-        final SqlCall multiply =
-                SqlStdOperatorTable.MULTIPLY.createCall(call.getParserPosition(), n, literal);
-        return cx.convertExpression(multiply);
-    }
-
-    // ~ Methods ----------------------------------------------------------------
-
-    private static RexNode or(RexBuilder rexBuilder, RexNode a0, RexNode a1) {
-        return rexBuilder.makeCall(SqlStdOperatorTable.OR, a0, a1);
-    }
-
-    private static RexNode eq(RexBuilder rexBuilder, RexNode a0, RexNode a1) {
-        return rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, a0, a1);
-    }
-
-    private static RexNode ge(RexBuilder rexBuilder, RexNode a0, RexNode a1) {
-        return rexBuilder.makeCall(SqlStdOperatorTable.GREATER_THAN_OR_EQUAL, a0, a1);
-    }
-
-    private static RexNode le(RexBuilder rexBuilder, RexNode a0, RexNode a1) {
-        return rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN_OR_EQUAL, a0, a1);
-    }
-
-    private static RexNode and(RexBuilder rexBuilder, RexNode a0, RexNode a1) {
-        return rexBuilder.makeCall(SqlStdOperatorTable.AND, a0, a1);
-    }
-
-    private static RexNode divideInt(RexBuilder rexBuilder, RexNode a0, RexNode a1) {
-        return rexBuilder.makeCall(SqlStdOperatorTable.DIVIDE_INTEGER, a0, a1);
-    }
-
-    private static RexNode plus(RexBuilder rexBuilder, RexNode a0, RexNode a1) {
-        return rexBuilder.makeCall(SqlStdOperatorTable.PLUS, a0, a1);
-    }
-
-    private static RexNode minus(RexBuilder rexBuilder, RexNode a0, RexNode a1) {
-        return rexBuilder.makeCall(SqlStdOperatorTable.MINUS, a0, a1);
-    }
-
-    private static RexNode multiply(RexBuilder rexBuilder, RexNode a0, RexNode a1) {
-        return rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY, a0, a1);
-    }
-
-    private static RexNode case_(RexBuilder rexBuilder, RexNode... args) {
-        return rexBuilder.makeCall(SqlStdOperatorTable.CASE, args);
-    }
-
-    // SqlNode helpers
-
-    private static SqlCall plus(SqlParserPos pos, SqlNode a0, SqlNode a1) {
-        return SqlStdOperatorTable.PLUS.createCall(pos, a0, a1);
-    }
-
-    /** Converts a CASE expression. */
-    public RexNode convertCase(SqlRexContext cx, SqlCase call) {
-        SqlNodeList whenList = call.getWhenOperands();
-        SqlNodeList thenList = call.getThenOperands();
-        assert whenList.size() == thenList.size();
-
-        RexBuilder rexBuilder = cx.getRexBuilder();
-        final List<RexNode> exprList = new ArrayList<>();
-        final RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory();
-        final RexLiteral unknownLiteral =
-                rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN));
-        final RexLiteral nullLiteral =
-                rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.NULL));
-        for (int i = 0; i < whenList.size(); i++) {
-            if (SqlUtil.isNullLiteral(whenList.get(i), false)) {
-                exprList.add(unknownLiteral);
-            } else {
-                exprList.add(cx.convertExpression(whenList.get(i)));
-            }
-            if (SqlUtil.isNullLiteral(thenList.get(i), false)) {
-                exprList.add(nullLiteral);
-            } else {
-                exprList.add(cx.convertExpression(thenList.get(i)));
-            }
-        }
-        SqlNode elseOperand = call.getElseOperand();
-        if (SqlUtil.isNullLiteral(elseOperand, false)) {
-            exprList.add(nullLiteral);
-        } else {
-            exprList.add(cx.convertExpression(requireNonNull(elseOperand, "elseOperand")));
-        }
-
-        RelDataType type = rexBuilder.deriveReturnType(call.getOperator(), exprList);
-        for (int i : elseArgs(exprList.size())) {
-            exprList.set(i, rexBuilder.ensureType(type, exprList.get(i), false));
-        }
-        return rexBuilder.makeCall(type, SqlStdOperatorTable.CASE, exprList);
-    }
-
-    public RexNode convertMultiset(SqlRexContext cx, SqlMultisetValueConstructor op, SqlCall call) {
-        final RelDataType originalType = cx.getValidator().getValidatedNodeType(call);
-        RexRangeRef rr = cx.getSubQueryExpr(call);
-        assert rr != null;
-        RelDataType msType = rr.getType().getFieldList().get(0).getType();
-        RexNode expr = cx.getRexBuilder().makeInputRef(msType, rr.getOffset());
-        assert msType.getComponentType() != null && msType.getComponentType().isStruct()
-                : "componentType of " + msType + " must be struct";
-        assert originalType.getComponentType() != null
-                : "componentType of " + originalType + " must be struct";
-        if (!originalType.getComponentType().isStruct()) {
-            // If the type is not a struct, the multiset operator will have
-            // wrapped the type as a record. Add a call to the $SLICE operator
-            // to compensate. For example,
-            // if '<ms>' has type 'RECORD (INTEGER x) MULTISET',
-            // then '$SLICE(<ms>) has type 'INTEGER MULTISET'.
-            // This will be removed as the expression is translated.
-            expr =
-                    cx.getRexBuilder()
-                            .makeCall(
-                                    originalType,
-                                    SqlStdOperatorTable.SLICE,
-                                    ImmutableList.of(expr));
-        }
-        return expr;
-    }
-
-    public RexNode convertArray(SqlRexContext cx, SqlArrayValueConstructor op, SqlCall call) {
-        return convertCall(cx, call);
-    }
-
-    public RexNode convertMap(SqlRexContext cx, SqlMapValueConstructor op, SqlCall call) {
-        return convertCall(cx, call);
-    }
-
-    public RexNode convertMultisetQuery(
-            SqlRexContext cx, SqlMultisetQueryConstructor op, SqlCall call) {
-        final RelDataType originalType = cx.getValidator().getValidatedNodeType(call);
-        RexRangeRef rr = cx.getSubQueryExpr(call);
-        assert rr != null;
-        RelDataType msType = rr.getType().getFieldList().get(0).getType();
-        RexNode expr = cx.getRexBuilder().makeInputRef(msType, rr.getOffset());
-        assert msType.getComponentType() != null
-                : "componentType of " + msType + " must not be null";
-        assert originalType.getComponentType() != null
-                : "componentType of " + originalType + " must not be null";
-        return expr;
-    }
-
-    public RexNode convertJdbc(SqlRexContext cx, SqlJdbcFunctionCall op, SqlCall call) {
-        // Yuck!! The function definition contains arguments!
-        // TODO: adopt a more conventional definition/instance structure
-        final SqlCall convertedCall = op.getLookupCall();
-        return cx.convertExpression(convertedCall);
-    }
-
-    protected RexNode convertCast(SqlRexContext cx, final SqlCall call) {
-        RelDataTypeFactory typeFactory = cx.getTypeFactory();
-        final SqlValidator validator = cx.getValidator();
-        final SqlKind kind = call.getKind();
-        checkArgument(kind == SqlKind.CAST || kind == SqlKind.SAFE_CAST, kind);
-        final boolean safe = kind == SqlKind.SAFE_CAST;
-        final SqlNode left = call.operand(0);
-        final SqlNode right = call.operand(1);
-        final SqlLiteral format =
-                call.getOperandList().size() > 2
-                        ? call.operand(2)
-                        : SqlLiteral.createNull(SqlParserPos.ZERO);
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        final RexNode arg = cx.convertExpression(left);
-        final RexLiteral formatArg = (RexLiteral) cx.convertLiteral(format);
-        if (right instanceof SqlIntervalQualifier) {
-            final SqlIntervalQualifier intervalQualifier = (SqlIntervalQualifier) right;
-            if (left instanceof SqlIntervalLiteral) {
-                RexLiteral sourceInterval = (RexLiteral) cx.convertExpression(left);
-                BigDecimal sourceValue = (BigDecimal) sourceInterval.getValue();
-                RexLiteral castedInterval =
-                        rexBuilder.makeIntervalLiteral(sourceValue, intervalQualifier);
-                return castToValidatedType(call, castedInterval, validator, rexBuilder, safe);
-            } else if (left instanceof SqlNumericLiteral) {
-                RexLiteral sourceInterval = (RexLiteral) cx.convertExpression(left);
-                BigDecimal sourceValue =
-                        requireNonNull(sourceInterval.getValueAs(BigDecimal.class), "sourceValue");
-                final BigDecimal multiplier = intervalQualifier.getUnit().multiplier;
-                RexLiteral castedInterval =
-                        rexBuilder.makeIntervalLiteral(
-                                SqlFunctions.multiply(sourceValue, multiplier), intervalQualifier);
-                return castToValidatedType(call, castedInterval, validator, rexBuilder, safe);
-            }
-            RexNode value = cx.convertExpression(left);
-            return castToValidatedType(call, value, validator, rexBuilder, safe);
-        }
-
-        final SqlDataTypeSpec dataType = (SqlDataTypeSpec) right;
-        RelDataType type =
-                SqlCastFunction.deriveType(
-                        cx.getTypeFactory(), arg.getType(), dataType.deriveType(validator), safe);
-        if (SqlUtil.isNullLiteral(left, false)) {
-            validator.setValidatedNodeType(left, type);
-            return cx.convertExpression(left);
-        }
-        if (null != dataType.getCollectionsTypeName()) {
-            RelDataType argComponentType = arg.getType().getComponentType();
-
-            // arg.getType() may be ANY
-            if (argComponentType == null) {
-                argComponentType = dataType.getComponentTypeSpec().deriveType(validator);
-            }
-
-            requireNonNull(argComponentType, () -> "componentType of " + arg);
-
-            RelDataType typeFinal = type;
-            final RelDataType componentType =
-                    requireNonNull(type.getComponentType(), () -> "componentType of " + typeFinal);
-            if (argComponentType.isStruct() && !componentType.isStruct()) {
-                RelDataType tt =
-                        typeFactory
-                                .builder()
-                                .add(
-                                        argComponentType.getFieldList().get(0).getName(),
-                                        componentType)
-                                .build();
-                tt = typeFactory.createTypeWithNullability(tt, componentType.isNullable());
-                boolean isn = type.isNullable();
-                type = typeFactory.createMultisetType(tt, -1);
-                type = typeFactory.createTypeWithNullability(type, isn);
-            }
-        }
-        return rexBuilder.makeCast(type, arg, safe, safe, formatArg);
-    }
-
-    protected RexNode convertFloorCeil(SqlRexContext cx, SqlCall call) {
-        final boolean floor = call.getKind() == SqlKind.FLOOR;
-        // Rewrite floor, ceil of interval
-        if (call.operandCount() == 1 && call.operand(0) instanceof SqlIntervalLiteral) {
-            final SqlIntervalLiteral literal = call.operand(0);
-            SqlIntervalLiteral.IntervalValue interval =
-                    literal.getValueAs(SqlIntervalLiteral.IntervalValue.class);
-            BigDecimal val = interval.getIntervalQualifier().getStartUnit().multiplier;
-            RexNode rexInterval = cx.convertExpression(literal);
-
-            final RexBuilder rexBuilder = cx.getRexBuilder();
-            RexNode zero = rexBuilder.makeExactLiteral(BigDecimal.valueOf(0));
-            RexNode cond = ge(rexBuilder, rexInterval, zero);
-
-            RexNode pad = rexBuilder.makeExactLiteral(val.subtract(BigDecimal.ONE));
-            RexNode cast =
-                    rexBuilder.makeReinterpretCast(
-                            rexInterval.getType(), pad, rexBuilder.makeLiteral(false));
-            RexNode sum =
-                    floor
-                            ? minus(rexBuilder, rexInterval, cast)
-                            : plus(rexBuilder, rexInterval, cast);
-
-            RexNode kase =
-                    floor
-                            ? case_(rexBuilder, rexInterval, cond, sum)
-                            : case_(rexBuilder, sum, cond, rexInterval);
-
-            RexNode factor = rexBuilder.makeExactLiteral(val);
-            RexNode div = divideInt(rexBuilder, kase, factor);
-            return multiply(rexBuilder, div, factor);
-        }
-
-        // normal floor, ceil function
-        return convertFunction(cx, (SqlFunction) call.getOperator(), call);
-    }
-
-    protected RexNode convertCharset(SqlRexContext cx, SqlCall call) {
-        final SqlNode expr = call.operand(0);
-        final String srcCharset = call.operand(1).toString();
-        final String destCharset = call.operand(2).toString();
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        return rexBuilder.makeCall(
-                SqlStdOperatorTable.CONVERT,
-                cx.convertExpression(expr),
-                rexBuilder.makeLiteral(srcCharset),
-                rexBuilder.makeLiteral(destCharset));
-    }
-
-    protected RexNode translateCharset(SqlRexContext cx, SqlCall call) {
-        final SqlNode expr = call.operand(0);
-        final String transcodingName = call.operand(1).toString();
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        return rexBuilder.makeCall(
-                SqlStdOperatorTable.TRANSLATE,
-                cx.convertExpression(expr),
-                rexBuilder.makeLiteral(transcodingName));
-    }
-
-    /**
-     * Converts a call to the {@code EXTRACT} function.
-     *
-     * <p>Called automatically via reflection.
-     */
-    public RexNode convertExtract(SqlRexContext cx, SqlExtractFunction op, SqlCall call) {
-        return convertFunction(cx, (SqlFunction) call.getOperator(), call);
-    }
-
-    @SuppressWarnings("unused")
-    private static RexNode mod(
-            RexBuilder rexBuilder, RelDataType resType, RexNode res, BigDecimal val) {
-        if (val.equals(BigDecimal.ONE)) {
-            return res;
-        }
-        return rexBuilder.makeCall(
-                SqlStdOperatorTable.MOD, res, rexBuilder.makeExactLiteral(val, resType));
-    }
-
-    private static RexNode divide(RexBuilder rexBuilder, RexNode res, BigDecimal val) {
-        if (val.equals(BigDecimal.ONE)) {
-            return res;
-        }
-        // If val is between 0 and 1, rather than divide by val, multiply by its
-        // reciprocal. For example, rather than divide by 0.001 multiply by 1000.
-        if (val.compareTo(BigDecimal.ONE) < 0 && val.signum() == 1) {
-            try {
-                final BigDecimal reciprocal = BigDecimal.ONE.divide(val, RoundingMode.UNNECESSARY);
-                return multiply(rexBuilder, res, rexBuilder.makeExactLiteral(reciprocal));
-            } catch (ArithmeticException e) {
-                // ignore - reciprocal is not an integer
-            }
-        }
-        return divideInt(rexBuilder, res, rexBuilder.makeExactLiteral(val));
-    }
-
-    public RexNode convertDatetimeMinus(
-            SqlRexContext cx, SqlDatetimeSubtractionOperator op, SqlCall call) {
-        // Rewrite datetime minus
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        final List<RexNode> exprs =
-                convertOperands(cx, call, SqlOperandTypeChecker.Consistency.NONE);
-
-        final RelDataType resType = cx.getValidator().getValidatedNodeType(call);
-        return rexBuilder.makeCall(resType, op, exprs.subList(0, 2));
-    }
-
-    public RexNode convertFunction(SqlRexContext cx, SqlFunction fun, SqlCall call) {
-        final List<RexNode> exprs =
-                convertOperands(cx, call, SqlOperandTypeChecker.Consistency.NONE);
-        if (fun.getFunctionType() == SqlFunctionCategory.USER_DEFINED_CONSTRUCTOR) {
-            return makeConstructorCall(cx, fun, exprs);
-        }
-        RelDataType returnType = cx.getValidator().getValidatedNodeTypeIfKnown(call);
-        if (returnType == null) {
-            returnType = cx.getRexBuilder().deriveReturnType(fun, exprs);
-        }
-        return cx.getRexBuilder().makeCall(returnType, fun, exprs);
-    }
-
-    public RexNode convertWindowFunction(
-            SqlRexContext cx, SqlWindowTableFunction fun, SqlCall call) {
-        // The first operand of window function is actually a query, skip that.
-        final List<SqlNode> operands = Util.skip(call.getOperandList());
-        final List<RexNode> exprs =
-                convertOperands(cx, call, operands, SqlOperandTypeChecker.Consistency.NONE);
-        RelDataType returnType = cx.getValidator().getValidatedNodeTypeIfKnown(call);
-        if (returnType == null) {
-            returnType = cx.getRexBuilder().deriveReturnType(fun, exprs);
-        }
-        return cx.getRexBuilder().makeCall(returnType, fun, exprs);
-    }
-
-    // BEGIN FLINK MODIFICATION
-    // Reason: this method is changed to extract return type from RETURNING clause of JSON_QUERY
-    // Whole class should be removed after CALCITE-6365 is fixed
-    public RexNode convertJsonValueFunction(
-            SqlRexContext cx, SqlJsonValueFunction fun, SqlCall call) {
-        return convertJsonReturningFunction(
-                cx,
-                fun,
-                call,
-                SqlJsonValueFunction::hasExplicitTypeSpec,
-                SqlJsonValueFunction::removeTypeSpecOperands);
-    }
-
-    public RexNode convertJsonQueryFunction(
-            SqlRexContext cx, SqlJsonQueryFunction fun, SqlCall call) {
-        return convertJsonReturningFunction(
-                cx,
-                fun,
-                call,
-                SqlJsonQueryFunction::hasExplicitTypeSpec,
-                SqlJsonQueryFunction::removeTypeSpecOperands);
-    }
-
-    public RexNode convertJsonReturningFunction(
-            SqlRexContext cx,
-            SqlFunction fun,
-            SqlCall call,
-            Predicate<SqlNode[]> hasExplicitTypeSpec,
-            Function<SqlCall, List<SqlNode>> removeTypeSpecOperands) {
-        // For Expression with explicit return type:
-        // i.e. json_query('{"foo":"bar"}', 'lax $.foo', returning varchar(2000))
-        // use the specified type as the return type.
-        List<SqlNode> operands = call.getOperandList();
-        @SuppressWarnings("all")
-        boolean hasExplicitReturningType =
-                hasExplicitTypeSpec.test(operands.toArray(SqlNode.EMPTY_ARRAY));
-        if (hasExplicitReturningType) {
-            operands = removeTypeSpecOperands.apply(call);
-        }
-        final List<RexNode> exprs =
-                convertOperands(cx, call, operands, SqlOperandTypeChecker.Consistency.NONE);
-        RelDataType returnType = cx.getValidator().getValidatedNodeTypeIfKnown(call);
-        requireNonNull(returnType, () -> "Unable to get type of " + call);
-        return cx.getRexBuilder().makeCall(returnType, fun, exprs);
-    }
-
-    // END FLINK MODIFICATION
-
-    public RexNode convertSequenceValue(
-            SqlRexContext cx, SqlSequenceValueOperator fun, SqlCall call) {
-        final List<SqlNode> operands = call.getOperandList();
-        assert operands.size() == 1;
-        assert operands.get(0) instanceof SqlIdentifier;
-        final SqlIdentifier id = (SqlIdentifier) operands.get(0);
-        final String key = Util.listToString(id.names);
-        RelDataType returnType = cx.getValidator().getValidatedNodeType(call);
-        return cx.getRexBuilder()
-                .makeCall(returnType, fun, ImmutableList.of(cx.getRexBuilder().makeLiteral(key)));
-    }
-
-    public RexNode convertAggregateFunction(SqlRexContext cx, SqlAggFunction fun, SqlCall call) {
-        final List<RexNode> exprs;
-        if (call.isCountStar()) {
-            exprs = ImmutableList.of();
-        } else {
-            exprs = convertOperands(cx, call, SqlOperandTypeChecker.Consistency.NONE);
-        }
-        RelDataType returnType = cx.getValidator().getValidatedNodeTypeIfKnown(call);
-        final int groupCount = cx.getGroupCount();
-        if (returnType == null) {
-            RexCallBinding binding =
-                    new RexCallBinding(cx.getTypeFactory(), fun, exprs, ImmutableList.of()) {
-                        @Override
-                        public int getGroupCount() {
-                            return groupCount;
-                        }
-                    };
-            returnType = fun.inferReturnType(binding);
-        }
-        return cx.getRexBuilder().makeCall(returnType, fun, exprs);
-    }
-
-    private static RexNode makeConstructorCall(
-            SqlRexContext cx, SqlFunction constructor, List<RexNode> exprs) {
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        RelDataType type = rexBuilder.deriveReturnType(constructor, exprs);
-
-        int n = type.getFieldCount();
-        ImmutableList.Builder<RexNode> initializationExprs = ImmutableList.builder();
-        final InitializerContext initializerContext =
-                new InitializerContext() {
-                    @Override
-                    public RexBuilder getRexBuilder() {
-                        return rexBuilder;
-                    }
-
-                    @Override
-                    public SqlNode validateExpression(RelDataType rowType, SqlNode expr) {
-                        throw new UnsupportedOperationException();
-                    }
-
-                    @Override
-                    public RexNode convertExpression(SqlNode e) {
-                        throw new UnsupportedOperationException();
-                    }
-                };
-        for (int i = 0; i < n; ++i) {
-            initializationExprs.add(
-                    cx.getInitializerExpressionFactory()
-                            .newAttributeInitializer(
-                                    type, constructor, i, exprs, initializerContext));
-        }
-
-        List<RexNode> defaultCasts =
-                RexUtil.generateCastExpressions(rexBuilder, type, initializationExprs.build());
-
-        return rexBuilder.makeNewInvocation(type, defaultCasts);
-    }
-
-    private RexNode convertItem(SqlRexContext cx, SqlCall call) {
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        final SqlOperator op = call.getOperator();
-        SqlOperandTypeChecker operandTypeChecker = op.getOperandTypeChecker();
-        final SqlOperandTypeChecker.Consistency consistency =
-                operandTypeChecker == null
-                        ? SqlOperandTypeChecker.Consistency.NONE
-                        : operandTypeChecker.getConsistency();
-        final List<RexNode> exprs = convertOperands(cx, call, consistency);
-
-        final RelDataType collectionType = exprs.get(0).getType();
-        final boolean isRowTypeField = SqlTypeUtil.isRow(collectionType);
-        final boolean isNumericIndex = SqlTypeUtil.isIntType(exprs.get(1).getType());
-
-        if (isRowTypeField && isNumericIndex) {
-            final SqlOperatorBinding opBinding =
-                    new RexCallBinding(cx.getTypeFactory(), op, exprs, ImmutableList.of());
-            final RelDataType operandType = opBinding.getOperandType(0);
-
-            final Integer index = opBinding.getOperandLiteralValue(1, Integer.class);
-            if (index == null || index < 1 || index > operandType.getFieldCount()) {
-                throw new AssertionError(
-                        "Cannot access field at position "
-                                + index
-                                + " within ROW type: "
-                                + operandType);
-            } else {
-                RelDataTypeField relDataTypeField = collectionType.getFieldList().get(index - 1);
-                return rexBuilder.makeFieldAccess(exprs.get(0), relDataTypeField.getName(), false);
-            }
-        }
-        RelDataType type = rexBuilder.deriveReturnType(op, exprs);
-        return rexBuilder.makeCall(type, op, RexUtil.flatten(exprs, op));
-    }
-
-    /**
-     * Converts a call to an operator into a {@link RexCall} to the same operator.
-     *
-     * <p>Called automatically via reflection.
-     *
-     * @param cx Context
-     * @param call Call
-     * @return Rex call
-     */
-    public RexNode convertCall(SqlRexContext cx, SqlCall call) {
-        final SqlOperator op = call.getOperator();
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        SqlOperandTypeChecker operandTypeChecker = op.getOperandTypeChecker();
-        final SqlOperandTypeChecker.Consistency consistency =
-                operandTypeChecker == null
-                        ? SqlOperandTypeChecker.Consistency.NONE
-                        : operandTypeChecker.getConsistency();
-        final List<RexNode> exprs = convertOperands(cx, call, consistency);
-        RelDataType type = rexBuilder.deriveReturnType(op, exprs);
-
-        // Expand 'ROW (x0, x1, ...) = ROW (y0, y1, ...)'
-        // to 'x0 = y0 AND x1 = y1 AND ...'
-        if (op.kind == SqlKind.EQUALS) {
-            final RexNode expr0 = RexUtil.removeCast(exprs.get(0));
-            final RexNode expr1 = RexUtil.removeCast(exprs.get(1));
-            if (expr0.getKind() == SqlKind.ROW && expr1.getKind() == SqlKind.ROW) {
-                final RexCall call0 = (RexCall) expr0;
-                final RexCall call1 = (RexCall) expr1;
-                final List<RexNode> eqList = new ArrayList<>();
-                Pair.forEach(
-                        call0.getOperands(),
-                        call1.getOperands(),
-                        (x, y) -> eqList.add(rexBuilder.makeCall(op, x, y)));
-                return RexUtil.composeConjunction(rexBuilder, eqList);
-            }
-        }
-        return rexBuilder.makeCall(type, op, RexUtil.flatten(exprs, op));
-    }
-
-    private static List<Integer> elseArgs(int count) {
-        // If list is odd, e.g. [0, 1, 2, 3, 4] we get [1, 3, 4]
-        // If list is even, e.g. [0, 1, 2, 3, 4, 5] we get [2, 4, 5]
-        final List<Integer> list = new ArrayList<>();
-        for (int i = count % 2; ; ) {
-            list.add(i);
-            i += 2;
-            if (i >= count) {
-                list.add(i - 1);
-                break;
-            }
-        }
-        return list;
-    }
-
-    private static List<RexNode> convertOperands(
-            SqlRexContext cx, SqlCall call, SqlOperandTypeChecker.Consistency consistency) {
-        List<SqlNode> operandList;
-        if (call.getOperator() instanceof SqlTableFunction) {
-            // skip set semantic table node of table function
-            operandList =
-                    call.getOperandList().stream()
-                            .filter(operand -> operand.getKind() != SqlKind.SET_SEMANTICS_TABLE)
-                            .collect(Collectors.toList());
-        } else {
-            operandList = call.getOperandList();
-        }
-        return convertOperands(cx, call, operandList, consistency);
-    }
-
-    private static List<RexNode> convertOperands(
-            SqlRexContext cx,
-            SqlCall call,
-            List<SqlNode> nodes,
-            SqlOperandTypeChecker.Consistency consistency) {
-        final List<RexNode> exprs = new ArrayList<>();
-        for (SqlNode node : nodes) {
-            exprs.add(cx.convertExpression(node));
-        }
-        final List<RelDataType> operandTypes = cx.getValidator().getValidatedOperandTypes(call);
-        if (operandTypes != null) {
-            final List<RexNode> oldExprs = new ArrayList<>(exprs);
-            exprs.clear();
-            Pair.forEach(
-                    oldExprs,
-                    operandTypes,
-                    (expr, type) -> exprs.add(cx.getRexBuilder().ensureType(type, expr, true)));
-        }
-        if (exprs.size() > 1) {
-            final RelDataType type = consistentType(cx, consistency, RexUtil.types(exprs));
-            if (type != null) {
-                final List<RexNode> oldExprs = new ArrayList<>(exprs);
-                exprs.clear();
-                for (RexNode expr : oldExprs) {
-                    exprs.add(cx.getRexBuilder().ensureType(type, expr, true));
-                }
-            }
-        }
-        return exprs;
-    }
-
-    private static @Nullable RelDataType consistentType(
-            SqlRexContext cx,
-            SqlOperandTypeChecker.Consistency consistency,
-            List<RelDataType> types) {
-        switch (consistency) {
-            case COMPARE:
-                if (SqlTypeUtil.areSameFamily(types)) {
-                    // All arguments are of same family. No need for explicit casts.
-                    return null;
-                }
-                final List<RelDataType> nonCharacterTypes = new ArrayList<>();
-                for (RelDataType type : types) {
-                    if (type.getFamily() != SqlTypeFamily.CHARACTER) {
-                        nonCharacterTypes.add(type);
-                    }
-                }
-                if (!nonCharacterTypes.isEmpty()) {
-                    final int typeCount = types.size();
-                    types = nonCharacterTypes;
-                    if (nonCharacterTypes.size() < typeCount) {
-                        final RelDataTypeFamily family = nonCharacterTypes.get(0).getFamily();
-                        if (family instanceof SqlTypeFamily) {
-                            // The character arguments might be larger than the numeric
-                            // argument. Give ourselves some headroom.
-                            switch ((SqlTypeFamily) family) {
-                                case INTEGER:
-                                case NUMERIC:
-                                    nonCharacterTypes.add(
-                                            cx.getTypeFactory().createSqlType(SqlTypeName.BIGINT));
-                                    break;
-                                default:
-                                    break;
-                            }
-                        }
-                    }
-                }
-            // fall through
-            case LEAST_RESTRICTIVE:
-                return cx.getTypeFactory().leastRestrictive(types);
-            default:
-                return null;
-        }
-    }
-
-    private RexNode convertPlus(SqlRexContext cx, SqlCall call) {
-        final RexNode rex = convertCall(cx, call);
-        switch (rex.getType().getSqlTypeName()) {
-            case DATE:
-            case TIME:
-            case TIMESTAMP:
-                // Use special "+" operator for datetime + interval.
-                // Re-order operands, if necessary, so that interval is second.
-                final RexBuilder rexBuilder = cx.getRexBuilder();
-                List<RexNode> operands = ((RexCall) rex).getOperands();
-                if (operands.size() == 2) {
-                    final SqlTypeName sqlTypeName = operands.get(0).getType().getSqlTypeName();
-                    switch (sqlTypeName) {
-                        case INTERVAL_YEAR:
-                        case INTERVAL_YEAR_MONTH:
-                        case INTERVAL_MONTH:
-                        case INTERVAL_DAY:
-                        case INTERVAL_DAY_HOUR:
-                        case INTERVAL_DAY_MINUTE:
-                        case INTERVAL_DAY_SECOND:
-                        case INTERVAL_HOUR:
-                        case INTERVAL_HOUR_MINUTE:
-                        case INTERVAL_HOUR_SECOND:
-                        case INTERVAL_MINUTE:
-                        case INTERVAL_MINUTE_SECOND:
-                        case INTERVAL_SECOND:
-                            operands = ImmutableList.of(operands.get(1), operands.get(0));
-                            break;
-                        default:
-                            break;
-                    }
-                }
-                return rexBuilder.makeCall(
-                        rex.getType(), SqlStdOperatorTable.DATETIME_PLUS, operands);
-            default:
-                return rex;
-        }
-    }
-
-    private RexNode convertIsDistinctFrom(SqlRexContext cx, SqlCall call, boolean neg) {
-        RexNode op0 = cx.convertExpression(call.operand(0));
-        RexNode op1 = cx.convertExpression(call.operand(1));
-        return RelOptUtil.isDistinctFrom(cx.getRexBuilder(), op0, op1, neg);
-    }
-
-    /**
-     * Converts a BETWEEN expression.
-     *
-     * <p>Called automatically via reflection.
-     */
-    public RexNode convertBetween(SqlRexContext cx, SqlBetweenOperator op, SqlCall call) {
-        SqlOperandTypeChecker operandTypeChecker = op.getOperandTypeChecker();
-        final SqlOperandTypeChecker.Consistency consistency =
-                operandTypeChecker == null
-                        ? SqlOperandTypeChecker.Consistency.NONE
-                        : operandTypeChecker.getConsistency();
-        final List<RexNode> list = convertOperands(cx, call, consistency);
-        final RexNode x = list.get(SqlBetweenOperator.VALUE_OPERAND);
-        final RexNode y = list.get(SqlBetweenOperator.LOWER_OPERAND);
-        final RexNode z = list.get(SqlBetweenOperator.UPPER_OPERAND);
-
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        RexNode ge1 = ge(rexBuilder, x, y);
-        RexNode le1 = le(rexBuilder, x, z);
-        RexNode and1 = and(rexBuilder, ge1, le1);
-
-        RexNode res;
-        final SqlBetweenOperator.Flag symmetric = op.flag;
-        switch (symmetric) {
-            case ASYMMETRIC:
-                res = and1;
-                break;
-            case SYMMETRIC:
-                RexNode ge2 = ge(rexBuilder, x, z);
-                RexNode le2 = le(rexBuilder, x, y);
-                RexNode and2 = and(rexBuilder, ge2, le2);
-                res = or(rexBuilder, and1, and2);
-                break;
-            default:
-                throw Util.unexpected(symmetric);
-        }
-        final SqlBetweenOperator betweenOp = (SqlBetweenOperator) call.getOperator();
-        if (betweenOp.isNegated()) {
-            res = rexBuilder.makeCall(SqlStdOperatorTable.NOT, res);
-        }
-        return res;
-    }
-
-    /**
-     * Converts a SUBSTRING expression.
-     *
-     * <p>Called automatically via reflection.
-     */
-    public RexNode convertSubstring(SqlRexContext cx, SqlSubstringFunction op, SqlCall call) {
-        final SqlLibrary library = cx.getValidator().config().conformance().semantics();
-        final SqlBasicCall basicCall = (SqlBasicCall) call;
-        switch (library) {
-            case BIG_QUERY:
-                return toRex(cx, basicCall, SqlLibraryOperators.SUBSTR_BIG_QUERY);
-            case MYSQL:
-                return toRex(cx, basicCall, SqlLibraryOperators.SUBSTR_MYSQL);
-            case ORACLE:
-                return toRex(cx, basicCall, SqlLibraryOperators.SUBSTR_ORACLE);
-            case POSTGRESQL:
-            default:
-                return convertFunction(cx, op, call);
-        }
-    }
-
-    private RexNode toRex(SqlRexContext cx, SqlBasicCall call, SqlFunction f) {
-        final SqlCall call2 = new SqlBasicCall(f, call.getOperandList(), call.getParserPosition());
-        final SqlRexConvertlet convertlet = requireNonNull(get(call2));
-        return convertlet.convertCall(cx, call2);
-    }
-
-    /**
-     * Converts a LiteralChain expression: that is, concatenates the operands immediately, to
-     * produce a single literal string.
-     *
-     * <p>Called automatically via reflection.
-     */
-    public RexNode convertLiteralChain(SqlRexContext cx, SqlLiteralChainOperator op, SqlCall call) {
-        Util.discard(cx);
-
-        SqlLiteral sum = SqlLiteralChainOperator.concatenateOperands(call);
-        return cx.convertLiteral(sum);
-    }
-
-    /**
-     * Converts a ROW.
-     *
-     * <p>Called automatically via reflection.
-     */
-    public RexNode convertRow(SqlRexContext cx, SqlRowOperator op, SqlCall call) {
-        if (cx.getValidator().getValidatedNodeType(call).getSqlTypeName()
-                != SqlTypeName.COLUMN_LIST) {
-            return convertCall(cx, call);
-        }
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        final List<RexNode> columns = new ArrayList<>();
-        for (String operand : SqlIdentifier.simpleNames(call.getOperandList())) {
-            columns.add(rexBuilder.makeLiteral(operand));
-        }
-        final RelDataType type =
-                rexBuilder.deriveReturnType(SqlStdOperatorTable.COLUMN_LIST, columns);
-        return rexBuilder.makeCall(type, SqlStdOperatorTable.COLUMN_LIST, columns);
-    }
-
-    /**
-     * Converts a call to OVERLAPS.
-     *
-     * <p>Called automatically via reflection.
-     */
-    public RexNode convertOverlaps(SqlRexContext cx, SqlOverlapsOperator op, SqlCall call) {
-        // for intervals [t0, t1] overlaps [t2, t3], we can find if the
-        // intervals overlaps by: ~(t1 < t2 or t3 < t0)
-        assert call.getOperandList().size() == 2;
-
-        final Pair<RexNode, RexNode> left =
-                convertOverlapsOperand(cx, call.getParserPosition(), call.operand(0));
-        final RexNode r0 = left.left;
-        final RexNode r1 = left.right;
-        final Pair<RexNode, RexNode> right =
-                convertOverlapsOperand(cx, call.getParserPosition(), call.operand(1));
-        final RexNode r2 = right.left;
-        final RexNode r3 = right.right;
-
-        // Sort end points into start and end, such that (s0 <= e0) and (s1 <= e1).
-        final RexBuilder rexBuilder = cx.getRexBuilder();
-        RexNode leftSwap = le(rexBuilder, r0, r1);
-        final RexNode s0 = case_(rexBuilder, leftSwap, r0, r1);
-        final RexNode e0 = case_(rexBuilder, leftSwap, r1, r0);
-        RexNode rightSwap = le(rexBuilder, r2, r3);
-        final RexNode s1 = case_(rexBuilder, rightSwap, r2, r3);
-        final RexNode e1 = case_(rexBuilder, rightSwap, r3, r2);
-        // (e0 >= s1) AND (e1 >= s0)
-        switch (op.kind) {
-            case OVERLAPS:
-                return and(rexBuilder, ge(rexBuilder, e0, s1), ge(rexBuilder, e1, s0));
-            case CONTAINS:
-                return and(rexBuilder, le(rexBuilder, s0, s1), ge(rexBuilder, e0, e1));
-            case PERIOD_EQUALS:
-                return and(rexBuilder, eq(rexBuilder, s0, s1), eq(rexBuilder, e0, e1));
-            case PRECEDES:
-                return le(rexBuilder, e0, s1);
-            case IMMEDIATELY_PRECEDES:
-                return eq(rexBuilder, e0, s1);
-            case SUCCEEDS:
-                return ge(rexBuilder, s0, e1);
-            case IMMEDIATELY_SUCCEEDS:
-                return eq(rexBuilder, s0, e1);
-            default:
-                throw new AssertionError(op);
-        }
-    }
-
-    private static Pair<RexNode, RexNode> convertOverlapsOperand(
-            SqlRexContext cx, SqlParserPos pos, SqlNode operand) {
-        final SqlNode a0;
-        final SqlNode a1;
-        switch (operand.getKind()) {
-            case ROW:
-                a0 = ((SqlCall) operand).operand(0);
-                final SqlNode a10 = ((SqlCall) operand).operand(1);
-                final RelDataType t1 = cx.getValidator().getValidatedNodeType(a10);
-                if (SqlTypeUtil.isInterval(t1)) {
-                    // make t1 = t0 + t1 when t1 is an interval.
-                    a1 = plus(pos, a0, a10);
-                } else {
-                    a1 = a10;
-                }
-                break;
-            default:
-                a0 = operand;
-                a1 = operand;
-        }
-
-        final RexNode r0 = cx.convertExpression(a0);
-        final RexNode r1 = cx.convertExpression(a1);
-        return Pair.of(r0, r1);
-    }
-
-    @Deprecated // to be removed before 2.0
-    public RexNode castToValidatedType(SqlRexContext cx, SqlCall call, RexNode value) {
-        return castToValidatedType(call, value, cx.getValidator(), cx.getRexBuilder(), false);
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RexNode castToValidatedType(
-            SqlNode node, RexNode e, SqlValidator validator, RexBuilder rexBuilder) {
-        return castToValidatedType(node, e, validator, rexBuilder, false);
-    }
-
-    /**
-     * Casts a RexNode value to the validated type of a SqlCall. If the value was already of the
-     * validated type, then the value is returned without an additional cast.
-     */
-    public static RexNode castToValidatedType(
-            SqlNode node, RexNode e, SqlValidator validator, RexBuilder rexBuilder, boolean safe) {
-        final RelDataType type = validator.getValidatedNodeType(node);
-        if (e.getType() == type) {
-            return e;
-        }
-        return rexBuilder.makeCast(type, e, safe, safe);
-    }
-
-    /**
-     * Convertlet that handles {@code COVAR_POP}, {@code COVAR_SAMP}, {@code REGR_SXX}, {@code
-     * REGR_SYY} windowed aggregate functions.
-     */
-    private static class RegrCovarianceConvertlet implements SqlRexConvertlet {
-        private final SqlKind kind;
-
-        RegrCovarianceConvertlet(SqlKind kind) {
-            this.kind = kind;
-        }
-
-        @Override
-        public RexNode convertCall(SqlRexContext cx, SqlCall call) {
-            assert call.operandCount() == 2;
-            final SqlNode arg1 = call.operand(0);
-            final SqlNode arg2 = call.operand(1);
-            final SqlNode expr;
-            final RelDataType type = cx.getValidator().getValidatedNodeType(call);
-            switch (kind) {
-                case COVAR_POP:
-                    expr = expandCovariance(arg1, arg2, null, type, cx, true);
-                    break;
-                case COVAR_SAMP:
-                    expr = expandCovariance(arg1, arg2, null, type, cx, false);
-                    break;
-                case REGR_SXX:
-                    expr = expandRegrSzz(arg2, arg1, type, cx, true);
-                    break;
-                case REGR_SYY:
-                    expr = expandRegrSzz(arg1, arg2, type, cx, true);
-                    break;
-                default:
-                    throw Util.unexpected(kind);
-            }
-            RexNode rex = cx.convertExpression(expr);
-            return cx.getRexBuilder().ensureType(type, rex, true);
-        }
-
-        private static SqlNode expandRegrSzz(
-                final SqlNode arg1,
-                final SqlNode arg2,
-                final RelDataType avgType,
-                final SqlRexContext cx,
-                boolean variance) {
-            final SqlParserPos pos = SqlParserPos.ZERO;
-            final SqlNode count = SqlStdOperatorTable.REGR_COUNT.createCall(pos, arg1, arg2);
-            final SqlNode varPop =
-                    expandCovariance(arg1, variance ? arg1 : arg2, arg2, avgType, cx, true);
-            final RexNode varPopRex = cx.convertExpression(varPop);
-            final SqlNode varPopCast;
-            varPopCast = getCastedSqlNode(varPop, avgType, pos, varPopRex);
-            return SqlStdOperatorTable.MULTIPLY.createCall(pos, varPopCast, count);
-        }
-
-        private static SqlNode expandCovariance(
-                final SqlNode arg0Input,
-                final SqlNode arg1Input,
-                final @Nullable SqlNode dependent,
-                final RelDataType varType,
-                final SqlRexContext cx,
-                boolean biased) {
-            // covar_pop(x1, x2) ==>
-            //     (sum(x1 * x2) - sum(x2) * sum(x1) / count(x1, x2))
-            //     / count(x1, x2)
-            //
-            // covar_samp(x1, x2) ==>
-            //     (sum(x1 * x2) - sum(x1) * sum(x2) / count(x1, x2))
-            //     / (count(x1, x2) - 1)
-            final SqlParserPos pos = SqlParserPos.ZERO;
-            final SqlLiteral nullLiteral = SqlLiteral.createNull(SqlParserPos.ZERO);
-
-            final RexNode arg0Rex = cx.convertExpression(arg0Input);
-            final RexNode arg1Rex = cx.convertExpression(arg1Input);
-
-            final SqlNode arg0 = getCastedSqlNode(arg0Input, varType, pos, arg0Rex);
-            final SqlNode arg1 = getCastedSqlNode(arg1Input, varType, pos, arg1Rex);
-            final SqlNode argSquared = SqlStdOperatorTable.MULTIPLY.createCall(pos, arg0, arg1);
-            final SqlNode sumArgSquared;
-            final SqlNode sum0;
-            final SqlNode sum1;
-            final SqlNode count;
-            if (dependent == null) {
-                sumArgSquared = SqlStdOperatorTable.SUM.createCall(pos, argSquared);
-                sum0 = SqlStdOperatorTable.SUM.createCall(pos, arg0, arg1);
-                sum1 = SqlStdOperatorTable.SUM.createCall(pos, arg1, arg0);
-                count = SqlStdOperatorTable.REGR_COUNT.createCall(pos, arg0, arg1);
-            } else {
-                sumArgSquared = SqlStdOperatorTable.SUM.createCall(pos, argSquared, dependent);
-                sum0 =
-                        SqlStdOperatorTable.SUM.createCall(
-                                pos, arg0, Objects.equals(dependent, arg0Input) ? arg1 : dependent);
-                sum1 =
-                        SqlStdOperatorTable.SUM.createCall(
-                                pos, arg1, Objects.equals(dependent, arg1Input) ? arg0 : dependent);
-                count =
-                        SqlStdOperatorTable.REGR_COUNT.createCall(
-                                pos, arg0, Objects.equals(dependent, arg0Input) ? arg1 : dependent);
-            }
-
-            final SqlNode sumSquared = SqlStdOperatorTable.MULTIPLY.createCall(pos, sum0, sum1);
-            final SqlNode countCasted =
-                    getCastedSqlNode(count, varType, pos, cx.convertExpression(count));
-
-            final SqlNode avgSumSquared =
-                    SqlStdOperatorTable.DIVIDE.createCall(pos, sumSquared, countCasted);
-            final SqlNode diff =
-                    SqlStdOperatorTable.MINUS.createCall(pos, sumArgSquared, avgSumSquared);
-            SqlNode denominator;
-            if (biased) {
-                denominator = countCasted;
-            } else {
-                final SqlNumericLiteral one = SqlLiteral.createExactNumeric("1", pos);
-                denominator =
-                        new SqlCase(
-                                SqlParserPos.ZERO,
-                                countCasted,
-                                SqlNodeList.of(
-                                        SqlStdOperatorTable.EQUALS.createCall(
-                                                pos, countCasted, one)),
-                                SqlNodeList.of(getCastedSqlNode(nullLiteral, varType, pos, null)),
-                                SqlStdOperatorTable.MINUS.createCall(pos, countCasted, one));
-            }
-
-            return SqlStdOperatorTable.DIVIDE.createCall(pos, diff, denominator);
-        }
-
-        private static SqlNode getCastedSqlNode(
-                SqlNode argInput, RelDataType varType, SqlParserPos pos, @Nullable RexNode argRex) {
-            if (argRex == null || argRex.getType().equals(varType)) {
-                return argInput;
-            }
-            return SqlStdOperatorTable.CAST.createCall(
-                    pos, argInput, SqlTypeUtil.convertTypeToSpec(varType));
-        }
-    }
-
-    /** Convertlet that handles {@code AVG} and {@code VARIANCE} windowed aggregate functions. */
-    private static class AvgVarianceConvertlet implements SqlRexConvertlet {
-        private final SqlKind kind;
-
-        AvgVarianceConvertlet(SqlKind kind) {
-            this.kind = kind;
-        }
-
-        @Override
-        public RexNode convertCall(SqlRexContext cx, SqlCall call) {
-            assert call.operandCount() == 1;
-            final SqlNode arg = call.operand(0);
-            final SqlNode expr;
-            final RelDataType type = cx.getValidator().getValidatedNodeType(call);
-            switch (kind) {
-                case AVG:
-                    expr = expandAvg(arg, type, cx);
-                    break;
-                case STDDEV_POP:
-                    expr = expandVariance(arg, type, cx, true, true);
-                    break;
-                case STDDEV_SAMP:
-                    expr = expandVariance(arg, type, cx, false, true);
-                    break;
-                case VAR_POP:
-                    expr = expandVariance(arg, type, cx, true, false);
-                    break;
-                case VAR_SAMP:
-                    expr = expandVariance(arg, type, cx, false, false);
-                    break;
-                default:
-                    throw Util.unexpected(kind);
-            }
-            RexNode rex = cx.convertExpression(expr);
-            return cx.getRexBuilder().ensureType(type, rex, true);
-        }
-
-        private static SqlNode expandAvg(
-                final SqlNode arg, final RelDataType avgType, final SqlRexContext cx) {
-            final SqlParserPos pos = SqlParserPos.ZERO;
-            final SqlNode sum = SqlStdOperatorTable.SUM.createCall(pos, arg);
-            final RexNode sumRex = cx.convertExpression(sum);
-            final SqlNode sumCast;
-            sumCast = getCastedSqlNode(sum, avgType, pos, sumRex);
-            final SqlNode count = SqlStdOperatorTable.COUNT.createCall(pos, arg);
-            return SqlStdOperatorTable.DIVIDE.createCall(pos, sumCast, count);
-        }
-
-        private static SqlNode expandVariance(
-                final SqlNode argInput,
-                final RelDataType varType,
-                final SqlRexContext cx,
-                boolean biased,
-                boolean sqrt) {
-            // stddev_pop(x) ==>
-            //   power(
-            //     (sum(x * x) - sum(x) * sum(x) / count(x))
-            //     / count(x),
-            //     .5)
-            //
-            // stddev_samp(x) ==>
-            //   power(
-            //     (sum(x * x) - sum(x) * sum(x) / count(x))
-            //     / (count(x) - 1),
-            //     .5)
-            //
-            // var_pop(x) ==>
-            //     (sum(x * x) - sum(x) * sum(x) / count(x))
-            //     / count(x)
-            //
-            // var_samp(x) ==>
-            //     (sum(x * x) - sum(x) * sum(x) / count(x))
-            //     / (count(x) - 1)
-            final SqlParserPos pos = SqlParserPos.ZERO;
-
-            final SqlNode arg =
-                    getCastedSqlNode(argInput, varType, pos, cx.convertExpression(argInput));
-
-            final SqlNode argSquared = SqlStdOperatorTable.MULTIPLY.createCall(pos, arg, arg);
-            final SqlNode argSquaredCasted =
-                    getCastedSqlNode(argSquared, varType, pos, cx.convertExpression(argSquared));
-            final SqlNode sumArgSquared = SqlStdOperatorTable.SUM.createCall(pos, argSquaredCasted);
-            final SqlNode sumArgSquaredCasted =
-                    getCastedSqlNode(
-                            sumArgSquared, varType, pos, cx.convertExpression(sumArgSquared));
-            final SqlNode sum = SqlStdOperatorTable.SUM.createCall(pos, arg);
-            final SqlNode sumCasted =
-                    getCastedSqlNode(sum, varType, pos, cx.convertExpression(sum));
-            final SqlNode sumSquared =
-                    SqlStdOperatorTable.MULTIPLY.createCall(pos, sumCasted, sumCasted);
-            final SqlNode sumSquaredCasted =
-                    getCastedSqlNode(sumSquared, varType, pos, cx.convertExpression(sumSquared));
-            final SqlNode count = SqlStdOperatorTable.COUNT.createCall(pos, arg);
-            final SqlNode countCasted =
-                    getCastedSqlNode(count, varType, pos, cx.convertExpression(count));
-            final SqlNode avgSumSquared =
-                    SqlStdOperatorTable.DIVIDE.createCall(pos, sumSquaredCasted, countCasted);
-            final SqlNode avgSumSquaredCasted =
-                    getCastedSqlNode(
-                            avgSumSquared, varType, pos, cx.convertExpression(avgSumSquared));
-            final SqlNode diff =
-                    SqlStdOperatorTable.MINUS.createCall(
-                            pos, sumArgSquaredCasted, avgSumSquaredCasted);
-            final SqlNode diffCasted =
-                    getCastedSqlNode(diff, varType, pos, cx.convertExpression(diff));
-            final SqlNode denominator;
-            if (biased) {
-                denominator = countCasted;
-            } else {
-                final SqlNumericLiteral one = SqlLiteral.createExactNumeric("1", pos);
-                final SqlLiteral nullLiteral = SqlLiteral.createNull(SqlParserPos.ZERO);
-                denominator =
-                        new SqlCase(
-                                SqlParserPos.ZERO,
-                                count,
-                                SqlNodeList.of(
-                                        SqlStdOperatorTable.EQUALS.createCall(pos, count, one)),
-                                SqlNodeList.of(getCastedSqlNode(nullLiteral, varType, pos, null)),
-                                SqlStdOperatorTable.MINUS.createCall(pos, count, one));
-            }
-            final SqlNode div = SqlStdOperatorTable.DIVIDE.createCall(pos, diffCasted, denominator);
-            final SqlNode divCasted =
-                    getCastedSqlNode(div, varType, pos, cx.convertExpression(div));
-
-            SqlNode result = div;
-            if (sqrt) {
-                final SqlNumericLiteral half = SqlLiteral.createExactNumeric("0.5", pos);
-                result = SqlStdOperatorTable.POWER.createCall(pos, divCasted, half);
-            }
-            return result;
-        }
-
-        private static SqlNode getCastedSqlNode(
-                SqlNode argInput, RelDataType varType, SqlParserPos pos, @Nullable RexNode argRex) {
-            if (argRex == null || argRex.getType().equals(varType)) {
-                return argInput;
-            }
-            return SqlStdOperatorTable.CAST.createCall(
-                    pos, argInput, SqlTypeUtil.convertTypeToSpec(varType));
-        }
-    }
-
-    /** Convertlet that converts {@code LTRIM} and {@code RTRIM} to {@code TRIM}. */
-    private static class TrimConvertlet implements SqlRexConvertlet {
-        private final SqlTrimFunction.Flag flag;
-
-        TrimConvertlet(SqlTrimFunction.Flag flag) {
-            this.flag = flag;
-        }
-
-        @Override
-        public RexNode convertCall(SqlRexContext cx, SqlCall call) {
-            final RexBuilder rexBuilder = cx.getRexBuilder();
-            final RexNode operand = cx.convertExpression(call.getOperandList().get(0));
-            return rexBuilder.makeCall(
-                    SqlStdOperatorTable.TRIM,
-                    rexBuilder.makeFlag(flag),
-                    rexBuilder.makeLiteral(" "),
-                    operand);
-        }
-    }
-
-    /** Convertlet that converts {@code GREATEST} and {@code LEAST}. */
-    private static class GreatestConvertlet implements SqlRexConvertlet {
-        @Override
-        public RexNode convertCall(SqlRexContext cx, SqlCall call) {
-            // Translate
-            //   GREATEST(a, b, c, d)
-            // to
-            //   CASE
-            //   WHEN a IS NULL OR b IS NULL OR c IS NULL OR d IS NULL
-            //   THEN NULL
-            //   WHEN a > b AND a > c AND a > d
-            //   THEN a
-            //   WHEN b > c AND b > d
-            //   THEN b
-            //   WHEN c > d
-            //   THEN c
-            //   ELSE d
-            //   END
-            final RexBuilder rexBuilder = cx.getRexBuilder();
-            final RelDataType type = cx.getValidator().getValidatedNodeType(call);
-            final SqlBinaryOperator op;
-            switch (call.getKind()) {
-                case GREATEST:
-                    op = SqlStdOperatorTable.GREATER_THAN;
-                    break;
-                case LEAST:
-                    op = SqlStdOperatorTable.LESS_THAN;
-                    break;
-                default:
-                    throw new AssertionError();
-            }
-            final List<RexNode> exprs =
-                    convertOperands(cx, call, SqlOperandTypeChecker.Consistency.NONE);
-            final List<RexNode> list = new ArrayList<>();
-            final List<RexNode> orList = new ArrayList<>();
-            for (RexNode expr : exprs) {
-                orList.add(rexBuilder.makeCall(SqlStdOperatorTable.IS_NULL, expr));
-            }
-            list.add(RexUtil.composeDisjunction(rexBuilder, orList));
-            list.add(rexBuilder.makeNullLiteral(type));
-            for (int i = 0; i < exprs.size() - 1; i++) {
-                RexNode expr = exprs.get(i);
-                final List<RexNode> andList = new ArrayList<>();
-                for (int j = i + 1; j < exprs.size(); j++) {
-                    final RexNode expr2 = exprs.get(j);
-                    andList.add(rexBuilder.makeCall(op, expr, expr2));
-                }
-                list.add(RexUtil.composeConjunction(rexBuilder, andList));
-                list.add(expr);
-            }
-            list.add(exprs.get(exprs.size() - 1));
-            return rexBuilder.makeCall(type, SqlStdOperatorTable.CASE, list);
-        }
-    }
-
-    /** Convertlet that handles {@code FLOOR} and {@code CEIL} functions. */
-    private class FloorCeilConvertlet implements SqlRexConvertlet {
-        @Override
-        public RexNode convertCall(SqlRexContext cx, SqlCall call) {
-            return convertFloorCeil(cx, call);
-        }
-    }
-
-    /**
-     * Convertlet that handles the {@code SUBSTR} function; various dialects have slightly different
-     * specifications. PostgreSQL seems to comply with the ISO standard for the {@code SUBSTRING}
-     * function, and therefore Calcite's default behavior matches PostgreSQL.
-     */
-    private static class SubstrConvertlet implements SqlRexConvertlet {
-        private final SqlLibrary library;
-
-        SubstrConvertlet(SqlLibrary library) {
-            this.library = library;
-            Preconditions.checkArgument(
-                    library == SqlLibrary.ORACLE
-                            || library == SqlLibrary.MYSQL
-                            || library == SqlLibrary.BIG_QUERY
-                            || library == SqlLibrary.POSTGRESQL);
-        }
-
-        @Override
-        public RexNode convertCall(SqlRexContext cx, SqlCall call) {
-            // Translate
-            //   SUBSTR(value, start, length)
-            //
-            // to the following if we want PostgreSQL semantics:
-            //   SUBSTRING(value, start, length)
-            //
-            // to the following if we want Oracle semantics:
-            //   SUBSTRING(
-            //     value
-            //     FROM CASE
-            //          WHEN start = 0
-            //          THEN 1
-            //          WHEN start + (length(value) + 1) < 1
-            //          THEN length(value) + 1
-            //          WHEN start < 0
-            //          THEN start + (length(value) + 1)
-            //          ELSE start)
-            //     FOR CASE WHEN length < 0 THEN 0 ELSE length END)
-            //
-            // to the following in MySQL:
-            //   SUBSTRING(
-            //     value
-            //     FROM CASE
-            //          WHEN start = 0
-            //          THEN length(value) + 1    -- different from Oracle
-            //          WHEN start + (length(value) + 1) < 1
-            //          THEN length(value) + 1
-            //          WHEN start < 0
-            //          THEN start + length(value) + 1
-            //          ELSE start)
-            //     FOR CASE WHEN length < 0 THEN 0 ELSE length END)
-            //
-            // to the following if we want BigQuery semantics:
-            //   CASE
-            //   WHEN start + (length(value) + 1) < 1
-            //   THEN value
-            //   ELSE SUBSTRING(
-            //       value
-            //       FROM CASE
-            //            WHEN start = 0
-            //            THEN 1
-            //            WHEN start < 0
-            //            THEN start + length(value) + 1
-            //            ELSE start)
-            //       FOR CASE WHEN length < 0 THEN 0 ELSE length END)
-
-            final RexBuilder rexBuilder = cx.getRexBuilder();
-            final List<RexNode> exprs =
-                    convertOperands(cx, call, SqlOperandTypeChecker.Consistency.NONE);
-            final RexNode value = exprs.get(0);
-            final RexNode start = exprs.get(1);
-            final RelDataType startType = start.getType();
-            final RexLiteral zeroLiteral = rexBuilder.makeLiteral(0, startType);
-            final RexLiteral oneLiteral = rexBuilder.makeLiteral(1, startType);
-            final RexNode valueLength =
-                    SqlTypeUtil.isBinary(value.getType())
-                            ? rexBuilder.makeCall(SqlStdOperatorTable.OCTET_LENGTH, value)
-                            : rexBuilder.makeCall(SqlStdOperatorTable.CHAR_LENGTH, value);
-            final RexNode valueLengthPlusOne =
-                    rexBuilder.makeCall(SqlStdOperatorTable.PLUS, valueLength, oneLiteral);
-
-            final RexNode newStart;
-            switch (library) {
-                case POSTGRESQL:
-                    if (call.operandCount() == 2) {
-                        newStart =
-                                rexBuilder.makeCall(
-                                        SqlStdOperatorTable.CASE,
-                                        rexBuilder.makeCall(
-                                                SqlStdOperatorTable.LESS_THAN, start, oneLiteral),
-                                        oneLiteral,
-                                        start);
-                    } else {
-                        newStart = start;
-                    }
-                    break;
-                case BIG_QUERY:
-                    newStart =
-                            rexBuilder.makeCall(
-                                    SqlStdOperatorTable.CASE,
-                                    rexBuilder.makeCall(
-                                            SqlStdOperatorTable.EQUALS, start, zeroLiteral),
-                                    oneLiteral,
-                                    rexBuilder.makeCall(
-                                            SqlStdOperatorTable.LESS_THAN, start, zeroLiteral),
-                                    rexBuilder.makeCall(
-                                            SqlStdOperatorTable.PLUS, start, valueLengthPlusOne),
-                                    start);
-                    break;
-                default:
-                    newStart =
-                            rexBuilder.makeCall(
-                                    SqlStdOperatorTable.CASE,
-                                    rexBuilder.makeCall(
-                                            SqlStdOperatorTable.EQUALS, start, zeroLiteral),
-                                    library == SqlLibrary.MYSQL ? valueLengthPlusOne : oneLiteral,
-                                    rexBuilder.makeCall(
-                                            SqlStdOperatorTable.LESS_THAN,
-                                            rexBuilder.makeCall(
-                                                    SqlStdOperatorTable.PLUS,
-                                                    start,
-                                                    valueLengthPlusOne),
-                                            oneLiteral),
-                                    valueLengthPlusOne,
-                                    rexBuilder.makeCall(
-                                            SqlStdOperatorTable.LESS_THAN, start, zeroLiteral),
-                                    rexBuilder.makeCall(
-                                            SqlStdOperatorTable.PLUS, start, valueLengthPlusOne),
-                                    start);
-                    break;
-            }
-
-            if (call.operandCount() == 2) {
-                return rexBuilder.makeCall(SqlStdOperatorTable.SUBSTRING, value, newStart);
-            }
-
-            assert call.operandCount() == 3;
-            final RexNode length = exprs.get(2);
-            final RexNode newLength;
-            switch (library) {
-                case POSTGRESQL:
-                    newLength = length;
-                    break;
-                default:
-                    newLength =
-                            rexBuilder.makeCall(
-                                    SqlStdOperatorTable.CASE,
-                                    rexBuilder.makeCall(
-                                            SqlStdOperatorTable.LESS_THAN, length, zeroLiteral),
-                                    zeroLiteral,
-                                    length);
-            }
-            final RexNode substringCall =
-                    rexBuilder.makeCall(SqlStdOperatorTable.SUBSTRING, value, newStart, newLength);
-            switch (library) {
-                case BIG_QUERY:
-                    return rexBuilder.makeCall(
-                            SqlStdOperatorTable.CASE,
-                            rexBuilder.makeCall(
-                                    SqlStdOperatorTable.LESS_THAN,
-                                    rexBuilder.makeCall(
-                                            SqlStdOperatorTable.PLUS, start, valueLengthPlusOne),
-                                    oneLiteral),
-                            value,
-                            substringCall);
-                default:
-                    return substringCall;
-            }
-        }
-    }
-
-    /**
-     * Convertlet that handles the 3-argument {@code TIMESTAMPADD} function and the 2-argument
-     * BigQuery-style {@code TIMESTAMP_ADD} function.
-     */
-    private static class TimestampAddConvertlet implements SqlRexConvertlet {
-        @Override
-        public RexNode convertCall(SqlRexContext cx, SqlCall call) {
-            // TIMESTAMPADD(unit, count, timestamp)
-            //  => timestamp + count * INTERVAL '1' UNIT
-            // TIMESTAMP_ADD(timestamp, interval)
-            //  => timestamp + interval
-            // "timestamp" may be of type TIMESTAMP or TIMESTAMP WITH LOCAL TIME ZONE.
-            final RexBuilder rexBuilder = cx.getRexBuilder();
-            SqlIntervalQualifier qualifier;
-            final RexNode op1;
-            final RexNode op2;
-            switch (call.operandCount()) {
-                case 2:
-                    // BigQuery-style 'TIMESTAMP_ADD(timestamp, interval)'
-                    final SqlBasicCall operandCall = call.operand(1);
-                    qualifier = operandCall.operand(1);
-                    op1 = cx.convertExpression(operandCall.operand(0));
-                    op2 = cx.convertExpression(call.operand(0));
-                    break;
-                default:
-                    // JDBC-style 'TIMESTAMPADD(unit, count, timestamp)'
-                    qualifier = call.operand(0);
-                    op1 = cx.convertExpression(call.operand(1));
-                    op2 = cx.convertExpression(call.operand(2));
-            }
-
-            final TimeFrame timeFrame = cx.getValidator().validateTimeFrame(qualifier);
-            final TimeUnit unit = first(timeFrame.unit(), TimeUnit.EPOCH);
-            final RelDataType type = cx.getValidator().getValidatedNodeType(call);
-            if (unit == TimeUnit.EPOCH && qualifier.timeFrameName != null) {
-                // Custom time frames have a different path. They are kept as names,
-                // and then handled by Java functions such as
-                // SqlFunctions.customTimestampAdd.
-                final RexLiteral timeFrameName = rexBuilder.makeLiteral(qualifier.timeFrameName);
-                // If the TIMESTAMPADD call has type TIMESTAMP and op2 has type DATE
-                // (which can happen for sub-day time frames such as HOUR), cast op2 to
-                // TIMESTAMP.
-                final RexNode op2b = rexBuilder.makeCast(type, op2);
-                return rexBuilder.makeCall(
-                        type,
-                        SqlStdOperatorTable.TIMESTAMP_ADD,
-                        ImmutableList.of(timeFrameName, op1, op2b));
-            }
-
-            if (qualifier.getUnit() != unit) {
-                qualifier = new SqlIntervalQualifier(unit, null, qualifier.getParserPosition());
-            }
-
-            RexNode interval2Add;
-            switch (unit) {
-                case MICROSECOND:
-                case NANOSECOND:
-                    interval2Add =
-                            divide(
-                                    rexBuilder,
-                                    multiply(
-                                            rexBuilder,
-                                            rexBuilder.makeIntervalLiteral(
-                                                    BigDecimal.ONE, qualifier),
-                                            op1),
-                                    BigDecimal.ONE.divide(
-                                            unit.multiplier, RoundingMode.UNNECESSARY));
-                    break;
-                default:
-                    interval2Add =
-                            multiply(
-                                    rexBuilder,
-                                    rexBuilder.makeIntervalLiteral(unit.multiplier, qualifier),
-                                    op1);
-            }
-
-            return rexBuilder.makeCall(SqlStdOperatorTable.DATETIME_PLUS, op2, interval2Add);
-        }
-    }
-
-    /**
-     * Convertlet that handles the BigQuery {@code DATETIME_TRUNC} and {@code TIMESTAMP_TRUNC}
-     * functions. Ensures that DATE operands are cast to TIMESTAMPs to match the expected return
-     * type for BigQuery.
-     */
-    private static class TruncConvertlet implements SqlRexConvertlet {
-        @Override
-        public RexNode convertCall(SqlRexContext cx, SqlCall call) {
-            final RexBuilder rexBuilder = cx.getRexBuilder();
-            RexNode op1 = cx.convertExpression(call.operand(0));
-            RexNode op2 = cx.convertExpression(call.operand(1));
-            if (op1.getType().getSqlTypeName() == SqlTypeName.DATE) {
-                RelDataType type = cx.getValidator().getValidatedNodeType(call);
-                op1 = cx.getRexBuilder().makeCast(type, op1);
-            }
-            return rexBuilder.makeCall(call.getOperator(), op1, op2);
-        }
-    }
-
-    /** Convertlet that handles the BigQuery {@code TIMESTAMP_SUB} function. */
-    private static class TimestampSubConvertlet implements SqlRexConvertlet {
-        @Override
-        public RexNode convertCall(SqlRexContext cx, SqlCall call) {
-            // TIMESTAMP_SUB(timestamp, interval)
-            //  => timestamp - count * INTERVAL '1' UNIT
-            final RexBuilder rexBuilder = cx.getRexBuilder();
-            final SqlBasicCall operandCall = call.operand(1);
-            SqlIntervalQualifier qualifier = operandCall.operand(1);
-            final RexNode op1 = cx.convertExpression(operandCall.operand(0));
-            final RexNode op2 = cx.convertExpression(call.operand(0));
-            final TimeFrame timeFrame = cx.getValidator().validateTimeFrame(qualifier);
-            final TimeUnit unit = first(timeFrame.unit(), TimeUnit.EPOCH);
-            final RexNode interval2Sub;
-            switch (unit) {
-                // Fractional second units are converted to seconds using their
-                // associated multiplier.
-                case MICROSECOND:
-                case NANOSECOND:
-                    interval2Sub =
-                            divide(
-                                    rexBuilder,
-                                    multiply(
-                                            rexBuilder,
-                                            rexBuilder.makeIntervalLiteral(
-                                                    BigDecimal.ONE, qualifier),
-                                            op1),
-                                    BigDecimal.ONE.divide(
-                                            unit.multiplier, RoundingMode.UNNECESSARY));
-                    break;
-                default:
-                    interval2Sub =
-                            multiply(
-                                    rexBuilder,
-                                    rexBuilder.makeIntervalLiteral(unit.multiplier, qualifier),
-                                    op1);
-            }
-
-            return rexBuilder.makeCall(SqlInternalOperators.MINUS_DATE2, op2, interval2Sub);
-        }
-    }
-
-    /** Convertlet that handles the {@code TIMESTAMPDIFF} function. */
-    private static class TimestampDiffConvertlet implements SqlRexConvertlet {
-        @Override
-        public RexNode convertCall(SqlRexContext cx, SqlCall call) {
-            // The standard TIMESTAMPDIFF and BigQuery's TIMESTAMP_DIFF have two key
-            // differences. The first being the order of the subtraction, outlined
-            // below. The second is that BigQuery truncates each timestamp to the
-            // specified time unit before the difference is computed.
-            //
-            // In fact, all BigQuery functions (TIMESTAMP_DIFF, DATETIME_DIFF,
-            // DATE_DIFF) truncate before subtracting when applied to date intervals
-            // (DAY, WEEK, ISOWEEK, MONTH, YEAR, etc.)
-            //
-            // For example, if computing the number of weeks between two timestamps,
-            // one occurring on a Saturday and the other occurring the next day on
-            // Sunday, their week difference is 1. This is because the first timestamp
-            // is truncated to the previous Sunday. This is done by making calls to
-            // TIMESTAMP_TRUNC and the difference is then computed using their
-            // results.
-            //
-            // TIMESTAMPDIFF(unit, t1, t2)
-            //    => (t2 - t1) UNIT
-            // TIMESTAMP_DIFF(t1, t2, unit)
-            //    => (t1 - t2) UNIT
-            SqlIntervalQualifier qualifier;
-            final boolean preTruncate;
-            final RexNode op1;
-            final RexNode op2;
-            if (call.operand(0).getKind() == SqlKind.INTERVAL_QUALIFIER) {
-                qualifier = call.operand(0);
-                preTruncate = false;
-                op1 = cx.convertExpression(call.operand(1));
-                op2 = cx.convertExpression(call.operand(2));
-            } else {
-                qualifier = call.operand(2);
-                preTruncate = qualifier.isDate();
-                op1 = cx.convertExpression(call.operand(1));
-                op2 = cx.convertExpression(call.operand(0));
-            }
-            final RexBuilder rexBuilder = cx.getRexBuilder();
-            final RelDataTypeFactory typeFactory = cx.getTypeFactory();
-            final TimeFrame timeFrame = cx.getValidator().validateTimeFrame(qualifier);
-            final TimeUnit unit = first(timeFrame.unit(), TimeUnit.EPOCH);
-            UnaryOperator<RexNode> truncateFn = UnaryOperator.identity();
-
-            if (unit == TimeUnit.EPOCH && qualifier.timeFrameName != null) {
-                // Custom time frames have a different path. They are kept as names, and
-                // then handled by Java functions.
-                final RexLiteral timeFrameName = rexBuilder.makeLiteral(qualifier.timeFrameName);
-                // This additional logic accounts for BigQuery truncating prior to
-                // computing the difference.
-                if (preTruncate) {
-                    truncateFn =
-                            e ->
-                                    rexBuilder.makeCall(
-                                            e.getType(),
-                                            SqlLibraryOperators.TIMESTAMP_TRUNC,
-                                            ImmutableList.of(e, timeFrameName));
-                }
-                return rexBuilder.makeCall(
-                        cx.getValidator().getValidatedNodeType(call),
-                        SqlStdOperatorTable.TIMESTAMP_DIFF,
-                        ImmutableList.of(
-                                timeFrameName, truncateFn.apply(op1), truncateFn.apply(op2)));
-            }
-
-            if (preTruncate) {
-                // The timestamps should be truncated unless the time unit is HOUR, in
-                // which case only the whole number of hours between the timestamps
-                // should be returned.
-                final RexNode timeUnit = cx.convertExpression(qualifier);
-                truncateFn =
-                        e ->
-                                rexBuilder.makeCall(
-                                        e.getType(),
-                                        SqlLibraryOperators.TIMESTAMP_TRUNC,
-                                        ImmutableList.of(e, timeUnit));
-            }
-
-            BigDecimal multiplier = BigDecimal.ONE;
-            BigDecimal divider = BigDecimal.ONE;
-            SqlTypeName sqlTypeName =
-                    unit == TimeUnit.NANOSECOND ? SqlTypeName.BIGINT : SqlTypeName.INTEGER;
-            switch (unit) {
-                case MICROSECOND:
-                case MILLISECOND:
-                case NANOSECOND:
-                case WEEK:
-                    multiplier = BigDecimal.valueOf(DateTimeUtils.MILLIS_PER_SECOND);
-                    divider = unit.multiplier;
-                    qualifier =
-                            new SqlIntervalQualifier(
-                                    TimeUnit.SECOND, null, qualifier.getParserPosition());
-                    break;
-                case QUARTER:
-                case CENTURY:
-                case MILLENNIUM:
-                    divider = unit.multiplier;
-                    qualifier =
-                            new SqlIntervalQualifier(
-                                    TimeUnit.MONTH, null, qualifier.getParserPosition());
-                    break;
-                default:
-                    qualifier = new SqlIntervalQualifier(unit, null, qualifier.getParserPosition());
-                    break;
-            }
-
-            final RelDataType intervalType =
-                    typeFactory.createTypeWithNullability(
-                            typeFactory.createSqlIntervalType(qualifier),
-                            op1.getType().isNullable() || op2.getType().isNullable());
-            final RexNode call2 =
-                    rexBuilder.makeCall(
-                            intervalType,
-                            SqlStdOperatorTable.MINUS_DATE,
-                            ImmutableList.of(truncateFn.apply(op2), truncateFn.apply(op1)));
-            final RelDataType intType =
-                    typeFactory.createTypeWithNullability(
-                            typeFactory.createSqlType(sqlTypeName),
-                            SqlTypeUtil.containsNullable(call2.getType()));
-            RexNode e = rexBuilder.makeCast(intType, call2);
-            return rexBuilder.multiplyDivide(e, multiplier, divider);
-        }
-    }
-}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkConvertletTable.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkConvertletTable.java
index 546d83b480a12..c207814496426 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkConvertletTable.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkConvertletTable.java
@@ -38,6 +38,7 @@
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlTableFunction;
 import org.apache.calcite.sql.SqlUtil;
+import org.apache.calcite.sql.fun.SqlJsonQueryFunction;
 import org.apache.calcite.sql.validate.SqlValidatorImpl;
 import org.apache.calcite.sql2rel.SqlRexContext;
 import org.apache.calcite.sql2rel.SqlRexConvertlet;
@@ -66,6 +67,8 @@ public SqlRexConvertlet get(SqlCall call) {
         final SqlOperator operator = call.getOperator();
         if (operator == FlinkSqlOperatorTable.TRY_CAST) {
             return this::convertTryCast;
+        } else if (operator instanceof SqlJsonQueryFunction) {
+            return this::convertJsonQuery;
         } else if (operator instanceof SqlTableFunction) {
             return this::convertTableArgs;
         } else if (call instanceof SqlModelCall) {
@@ -80,6 +83,25 @@ private RexNode convertModelCall(SqlRexContext cx, final SqlCall call) {
         return modelCall.getModel().toRex(cx);
     }
 
+    private RexNode convertJsonQuery(SqlRexContext cx, SqlCall call) {
+        List<SqlNode> operands = new ArrayList<>();
+        for (SqlNode operand : call.getOperandList()) {
+            if (!(operand instanceof SqlDataTypeSpec)) {
+                operands.add(operand);
+            }
+        }
+        SqlCall strippedCall = call.getOperator().createCall(call.getParserPosition(), operands);
+        final List<RexNode> exprs = new ArrayList<>();
+        for (SqlNode operand : strippedCall.getOperandList()) {
+            exprs.add(cx.convertExpression(operand));
+        }
+        RelDataType returnType = cx.getValidator().getValidatedNodeTypeIfKnown(call);
+        if (returnType == null) {
+            returnType = cx.getRexBuilder().deriveReturnType(call.getOperator(), exprs);
+        }
+        return cx.getRexBuilder().makeCall(returnType, call.getOperator(), exprs);
+    }
+
     // Slightly modified version of StandardConvertletTable::convertCast
     private RexNode convertTryCast(SqlRexContext cx, final SqlCall call) {
         RelDataTypeFactory typeFactory = cx.getTypeFactory();
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkTypeFactory.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkTypeFactory.java
index fe18a71410e93..bb99230775c85 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkTypeFactory.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkTypeFactory.java
@@ -237,10 +237,9 @@ public RelDataType createTypeWithNullability(RelDataType relDataType, boolean is
             final TimeIndicatorRelDataType it = (TimeIndicatorRelDataType) relDataType;
             newType =
                     new TimeIndicatorRelDataType(
-                            it.typeSystemField(), it.originalType(), isNullable, it.isEventTime());
+                            it.getTypeSystem(), it.getOriginalType(), isNullable, it.isEventTime());
         } else if (relDataType instanceof RelRecordType
-                && ((RelRecordType) relDataType).getStructKind()
-                        == StructKind.PEEK_FIELDS_NO_EXPAND) {
+                && relDataType.getStructKind() == StructKind.PEEK_FIELDS_NO_EXPAND) {
             // for nested rows we keep the nullability property,
             // top-level rows fall back to Calcite's default handling
             final RelRecordType rt = (RelRecordType) relDataType;
@@ -571,7 +570,7 @@ public static boolean isProctimeIndicatorType(RelDataType relDataType) {
     public static boolean isTimestampLtzIndicatorType(RelDataType relDataType) {
         return relDataType instanceof TimeIndicatorRelDataType
                 && ((TimeIndicatorRelDataType) relDataType)
-                        .originalType()
+                        .getOriginalType()
                         .getSqlTypeName()
                         .equals(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
     }
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkTypeSystem.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkTypeSystem.java
index bfdd969396839..419254d54b630 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkTypeSystem.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkTypeSystem.java
@@ -100,6 +100,16 @@ public int getMaxPrecision(SqlTypeName typeName) {
         return super.getMaxPrecision(typeName);
     }
 
+    @Override
+    public int getMinScale(SqlTypeName typeName) {
+        switch (typeName) {
+            case DECIMAL:
+                return -DecimalType.MAX_PRECISION;
+            default:
+                return super.getMinScale(typeName);
+        }
+    }
+
     @Override
     public boolean shouldConvertRaggedUnionTypesToVarying() {
         // when union a number of CHAR types of different lengths, we should cast to a VARCHAR
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/RelTimeIndicatorConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/RelTimeIndicatorConverter.java
index 68fb063e3eb1e..262665155789d 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/RelTimeIndicatorConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/RelTimeIndicatorConverter.java
@@ -276,6 +276,7 @@ private RelNode visitLogicalOverAggregate(FlinkLogicalOverAggregate logical) {
                             group.isRows,
                             group.lowerBound,
                             group.upperBound,
+                            group.exclude,
                             group.orderKeys,
                             winCalls));
         }
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/serde/RexNodeJsonDeserializer.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/serde/RexNodeJsonDeserializer.java
index 2c063aade6477..2f344c13f535b 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/serde/RexNodeJsonDeserializer.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/serde/RexNodeJsonDeserializer.java
@@ -253,12 +253,14 @@ private static RexNode deserializeSarg(
         switch (sqlTypeName) {
             case BOOLEAN:
                 return valueNode.booleanValue();
+            case FLOAT:
+            case DOUBLE:
+            case REAL:
+                return Double.parseDouble(valueNode.asText());
             case TINYINT:
             case SMALLINT:
             case INTEGER:
             case BIGINT:
-            case FLOAT:
-            case DOUBLE:
             case DECIMAL:
             case INTERVAL_YEAR:
             case INTERVAL_YEAR_MONTH:
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/utils/CommonPythonUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/utils/CommonPythonUtil.java
index ae9a375ba646b..d82a37f5e7c8a 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/utils/CommonPythonUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/utils/CommonPythonUtil.java
@@ -370,11 +370,11 @@ private static byte[] convertLiteralToPython(
                     break;
                 case FLOAT:
                     type = 0;
-                    value = ((BigDecimal) o.getValue3()).floatValue();
+                    value = ((Number) o.getValue3()).floatValue();
                     break;
                 case DOUBLE:
                     type = 0;
-                    value = ((BigDecimal) o.getValue3()).doubleValue();
+                    value = ((Number) o.getValue3()).doubleValue();
                     break;
                 case DECIMAL:
                 case BOOLEAN:
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/PushWatermarkIntoTableSourceScanAcrossCalcRule.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/PushWatermarkIntoTableSourceScanAcrossCalcRule.java
index ff4012c9196dd..7ee58c9046ff2 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/PushWatermarkIntoTableSourceScanAcrossCalcRule.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/PushWatermarkIntoTableSourceScanAcrossCalcRule.java
@@ -94,7 +94,7 @@ public void onMatch(RelOptRuleCall call) {
                                 rowtimeExpr.getType().getSqlTypeName()
                                         == SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE),
                         rowtimeExpr,
-                        null);
+                        builder.makeLiteral(false));
         RexNode newWatermarkExpr =
                 watermarkAssigner
                         .watermarkExpr()
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/schema/TimeIndicatorRelDataType.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/schema/TimeIndicatorRelDataType.java
new file mode 100644
index 0000000000000..7c83217065959
--- /dev/null
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/schema/TimeIndicatorRelDataType.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.flink.table.planner.plan.schema;
+
+import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.calcite.sql.type.BasicSqlType;
+import org.apache.calcite.sql.type.SqlTypeName;
+
+/**
+ * Creates a time indicator type for event-time or processing-time, but with similar properties as a
+ * basic SQL type.
+ */
+public class TimeIndicatorRelDataType extends BasicSqlType {
+    private final boolean isEventTime;
+    private final BasicSqlType originalType;
+
+    public TimeIndicatorRelDataType(
+            RelDataTypeSystem typeSystem,
+            BasicSqlType originalType,
+            boolean nullable,
+            boolean isEventTime) {
+        super(typeSystem, originalType.getSqlTypeName(), nullable, originalType.getPrecision());
+        this.isEventTime = isEventTime;
+        this.originalType = originalType;
+        computeDigest();
+    }
+
+    public boolean isEventTime() {
+        return isEventTime;
+    }
+
+    public BasicSqlType getOriginalType() {
+        return originalType;
+    }
+
+    public RelDataTypeSystem getTypeSystem() {
+        return typeSystem;
+    }
+
+    @Override
+    public int hashCode() {
+        return super.hashCode()
+                + 42; // we change the hash code to differentiate from regular timestamps
+    }
+
+    @Override
+    public String toString() {
+        // Calcite caches type instance by the type string representation in
+        // org.apache.calcite.rel.type.RelDataTypeFactoryImpl, thus we use
+        // unique name for each TimeIndicatorRelDataType
+        final String typeNameStr =
+                (typeName == SqlTypeName.TIMESTAMP) ? "TIMESTAMP(3)" : "TIMESTAMP_LTZ(3)";
+        return typeNameStr + " " + (isEventTime ? "*ROWTIME*" : "*PROCTIME*");
+    }
+
+    @Override
+    public void generateTypeString(StringBuilder sb, boolean withDetail) {
+        sb.append(this);
+    }
+}
diff --git a/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE b/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
index ffedf68176966..9d88763d0746d 100644
--- a/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
+++ b/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
@@ -8,8 +8,8 @@ This project bundles the following dependencies under the Apache Software Licens
 
 - com.google.guava:guava:33.4.0-jre
 - com.google.guava:failureaccess:1.0.2
-- org.apache.calcite:calcite-core:1.37.0
-- org.apache.calcite:calcite-linq4j:1.37.0
+- org.apache.calcite:calcite-core:1.38.0
+- org.apache.calcite:calcite-linq4j:1.38.0
 - org.apache.calcite.avatica:avatica-core:1.25.0
 - org.apache.commons:commons-math3:3.6.1
 - org.apache.commons:commons-text:1.10.0
diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/codegen/ExpressionReducer.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/codegen/ExpressionReducer.scala
index b1c70fb9c5260..d41331309c3db 100644
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/codegen/ExpressionReducer.scala
+++ b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/codegen/ExpressionReducer.scala
@@ -285,13 +285,13 @@ class ExpressionReducer(
 
             // according to BuiltInFunctionDefinitions, the DEVIDE's second op must be numeric
             assert(RexUtil.isDeterministic(divisionLiteral))
-            val divisionComparable =
-              divisionLiteral.asInstanceOf[RexLiteral].getValue.asInstanceOf[Comparable[Any]]
-            val zeroComparable = rexBuilder
-              .makeExactLiteral(new java.math.BigDecimal(0))
-              .getValue
-              .asInstanceOf[Comparable[Any]]
-            if (divisionComparable.compareTo(zeroComparable) == 0) {
+            val divisionValue = divisionLiteral.asInstanceOf[RexLiteral].getValue
+            val isZero = divisionValue match {
+              case d: java.lang.Double => d == 0.0
+              case bd: java.math.BigDecimal => bd.signum() == 0
+              case _ => false
+            }
+            if (isZero) {
               throw new ArithmeticException("Division by zero")
             }
           }
diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchPhysicalOverAggregateRule.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchPhysicalOverAggregateRule.scala
index a428d03f95fbf..aafdf55b9906d 100644
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchPhysicalOverAggregateRule.scala
+++ b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchPhysicalOverAggregateRule.scala
@@ -239,6 +239,7 @@ class BatchPhysicalOverAggregateRule
             group.isRows,
             group.lowerBound,
             group.upperBound,
+            group.exclude,
             group.orderKeys,
             newAggCalls))
       }
diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/schema/TimeIndicatorRelDataType.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/schema/TimeIndicatorRelDataType.scala
deleted file mode 100644
index a4076db6adf1c..0000000000000
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/schema/TimeIndicatorRelDataType.scala
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.flink.table.planner.plan.schema
-
-import org.apache.calcite.rel.`type`.RelDataTypeSystem
-import org.apache.calcite.sql.`type`.BasicSqlType
-import org.apache.calcite.sql.`type`.SqlTypeName.TIMESTAMP
-
-import java.lang
-
-/**
- * Creates a time indicator type for event-time or processing-time, but with similar properties as a
- * basic SQL type.
- */
-class TimeIndicatorRelDataType(
-    val typeSystemField: RelDataTypeSystem,
-    val originalType: BasicSqlType,
-    val nullable: Boolean,
-    val isEventTime: Boolean)
-  extends BasicSqlType(typeSystemField, originalType.getSqlTypeName, originalType.getPrecision) {
-
-  this.isNullable = nullable
-  computeDigest()
-
-  override def hashCode(): Int = {
-    super.hashCode() + 42 // we change the hash code to differentiate from regular timestamps
-  }
-
-  override def toString: String = {
-    // Calcite caches type instance by the type string representation in
-    // org.apache.calcite.rel.type.RelDataTypeFactoryImpl, thus we use
-    // unique name for each TimeIndicatorRelDataType
-    s"${if (typeName == TIMESTAMP) "TIMESTAMP(3)" else "TIMESTAMP_LTZ(3)"}" +
-      s" ${if (isEventTime) "*ROWTIME*" else "*PROCTIME*"}"
-  }
-
-  override def generateTypeString(sb: lang.StringBuilder, withDetail: Boolean): Unit = {
-    sb.append(toString)
-  }
-}
diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/FlinkRelOptUtil.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/FlinkRelOptUtil.scala
index 8cb795e719bd6..cd030cc4ed28c 100644
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/FlinkRelOptUtil.scala
+++ b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/FlinkRelOptUtil.scala
@@ -288,7 +288,9 @@ object FlinkRelOptUtil {
     } else {
       literal.getTypeName match {
         case BOOLEAN => RexLiteral.booleanValue(literal)
-        case TINYINT | SMALLINT | INTEGER | BIGINT | FLOAT | DOUBLE | DECIMAL =>
+        case FLOAT | DOUBLE | REAL =>
+          BigDecimal.valueOf(literal.getValue3.asInstanceOf[Double])
+        case TINYINT | SMALLINT | INTEGER | BIGINT | DECIMAL =>
           literal.getValue3.asInstanceOf[BigDecimal]
         case VARCHAR | CHAR => literal.getValueAs(classOf[String])
 
diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/FlinkRexUtil.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/FlinkRexUtil.scala
index 94d262463c6ff..eb8fa26cc6291 100644
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/FlinkRexUtil.scala
+++ b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/FlinkRexUtil.scala
@@ -348,7 +348,7 @@ object FlinkRexUtil {
               "null:" + l.getType
             } else {
               l.getTypeName match {
-                case SqlTypeName.DOUBLE => Util.toScientificNotation(value.asInstanceOf[BigDecimal])
+                case SqlTypeName.DOUBLE => Util.toScientificNotation(value.asInstanceOf[Double])
                 case SqlTypeName.BIGINT => s"${value.asInstanceOf[BigDecimal].longValue()}L"
                 case SqlTypeName.BINARY => s"X'${value.asInstanceOf[ByteString].toString(16)}'"
                 case SqlTypeName.VARCHAR | SqlTypeName.CHAR =>
diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/OverAggregateUtil.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/OverAggregateUtil.scala
index d3e1128aa48a4..98cbfa134f8ee 100644
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/OverAggregateUtil.scala
+++ b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/OverAggregateUtil.scala
@@ -88,6 +88,7 @@ object OverAggregateUtil {
         windowGroup.isRows,
         windowGroup.lowerBound,
         windowGroup.upperBound,
+        windowGroup.exclude,
         windowGroup.orderKeys,
         newAggCalls)
     }
diff --git a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/functions/JsonFunctionsITCase.java b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/functions/JsonFunctionsITCase.java
index 89a0448e95eef..24942057cfb5c 100644
--- a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/functions/JsonFunctionsITCase.java
+++ b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/functions/JsonFunctionsITCase.java
@@ -316,59 +316,53 @@ private static List<TestSetSpec> isJsonSpec() {
                 TestSetSpec.forFunction(BuiltInFunctionDefinitions.IS_JSON)
                         .onFieldsWithData((String) null)
                         .andDataTypes(STRING())
-                        .testResult($("f0").isJson(), "f0 IS JSON", false, BOOLEAN().notNull()),
+                        .testResult($("f0").isJson(), "f0 IS JSON", false, BOOLEAN()),
                 TestSetSpec.forFunction(BuiltInFunctionDefinitions.IS_JSON)
                         .onFieldsWithData("a")
                         .andDataTypes(STRING())
-                        .testResult($("f0").isJson(), "f0 IS JSON", false, BOOLEAN().notNull()),
+                        .testResult($("f0").isJson(), "f0 IS JSON", false, BOOLEAN()),
                 TestSetSpec.forFunction(BuiltInFunctionDefinitions.IS_JSON)
                         .onFieldsWithData("\"a\"")
                         .andDataTypes(STRING())
-                        .testResult($("f0").isJson(), "f0 IS JSON", true, BOOLEAN().notNull())
+                        .testResult($("f0").isJson(), "f0 IS JSON", true, BOOLEAN())
                         .testResult(
-                                $("f0").isJson(JsonType.VALUE),
-                                "f0 IS JSON VALUE",
-                                true,
-                                BOOLEAN().notNull())
+                                $("f0").isJson(JsonType.VALUE), "f0 IS JSON VALUE", true, BOOLEAN())
                         .testResult(
                                 $("f0").isJson(JsonType.SCALAR),
                                 "f0 IS JSON SCALAR",
                                 true,
-                                BOOLEAN().notNull())
+                                BOOLEAN())
                         .testResult(
                                 $("f0").isJson(JsonType.ARRAY),
                                 "f0 IS JSON ARRAY",
                                 false,
-                                BOOLEAN().notNull())
+                                BOOLEAN())
                         .testResult(
                                 $("f0").isJson(JsonType.OBJECT),
                                 "f0 IS JSON OBJECT",
                                 false,
-                                BOOLEAN().notNull()),
+                                BOOLEAN()),
                 TestSetSpec.forFunction(BuiltInFunctionDefinitions.IS_JSON)
                         .onFieldsWithData("{}")
                         .andDataTypes(STRING())
-                        .testResult($("f0").isJson(), "f0 IS JSON", true, BOOLEAN().notNull())
+                        .testResult($("f0").isJson(), "f0 IS JSON", true, BOOLEAN())
                         .testResult(
-                                $("f0").isJson(JsonType.VALUE),
-                                "f0 IS JSON VALUE",
-                                true,
-                                BOOLEAN().notNull())
+                                $("f0").isJson(JsonType.VALUE), "f0 IS JSON VALUE", true, BOOLEAN())
                         .testResult(
                                 $("f0").isJson(JsonType.SCALAR),
                                 "f0 IS JSON SCALAR",
                                 false,
-                                BOOLEAN().notNull())
+                                BOOLEAN())
                         .testResult(
                                 $("f0").isJson(JsonType.ARRAY),
                                 "f0 IS JSON ARRAY",
                                 false,
-                                BOOLEAN().notNull())
+                                BOOLEAN())
                         .testResult(
                                 $("f0").isJson(JsonType.OBJECT),
                                 "f0 IS JSON OBJECT",
                                 true,
-                                BOOLEAN().notNull()));
+                                BOOLEAN()));
     }
 
     private static List<TestSetSpec> jsonQuerySpec() {
diff --git a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlNodeToCallOperationTest.java b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlNodeToCallOperationTest.java
index c47d243108083..a3ea7824c65cb 100644
--- a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlNodeToCallOperationTest.java
+++ b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlNodeToCallOperationTest.java
@@ -115,7 +115,7 @@ void testCallStatement() {
                 sql,
                 "CALL PROCEDURE:"
                         + " (procedureIdentifier: [`p1`.`system`.`row_result`],"
-                        + " inputTypes: [DECIMAL(10, 2)], outputTypes: [ROW<`i` INT>], arguments: [1.20])");
+                        + " inputTypes: [DECIMAL(10, 2)], outputTypes: [ROW<`i` INT>], arguments: [1.00])");
         sql = "call `system`.row_result(1.2)";
         verifyCallOperation(
                 sql,
diff --git a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/batch/sql/RowLevelUpdateTest.java b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/batch/sql/RowLevelUpdateTest.java
index 57f22238d0540..6ad58f9fb9011 100644
--- a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/batch/sql/RowLevelUpdateTest.java
+++ b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/batch/sql/RowLevelUpdateTest.java
@@ -19,8 +19,8 @@
 package org.apache.flink.table.planner.plan.batch.sql;
 
 import org.apache.flink.table.api.ExplainDetail;
-import org.apache.flink.table.api.SqlParserException;
 import org.apache.flink.table.api.TableConfig;
+import org.apache.flink.table.api.ValidationException;
 import org.apache.flink.table.api.config.ExecutionConfigOptions;
 import org.apache.flink.table.connector.sink.abilities.SupportsRowLevelUpdate;
 import org.apache.flink.table.planner.utils.BatchTableTestUtil;
@@ -173,12 +173,13 @@ void testUpdateWithCompositeType() {
                                         + ") ",
                                 updateMode));
 
-        assertThatExceptionOfType(SqlParserException.class)
+        assertThatExceptionOfType(ValidationException.class)
                 .isThrownBy(
                         () ->
                                 util.verifyExplainInsert(
                                         "UPDATE t SET b.b1 = 'v2', c.c1 = 1000 WHERE b = '123'",
-                                        explainDetails));
+                                        explainDetails))
+                .withMessageContaining("Unknown target column 'b.b1'");
     }
 
     private void createTableForUpdate() {
diff --git a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/serde/RexNodeJsonSerdeTest.java b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/serde/RexNodeJsonSerdeTest.java
index 2cd692ca097d1..ee6e450e19d2a 100644
--- a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/serde/RexNodeJsonSerdeTest.java
+++ b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/serde/RexNodeJsonSerdeTest.java
@@ -720,7 +720,7 @@ private static Stream<RexNode> testRexNodeSerde() {
                         FACTORY.createSqlType(SqlTypeName.INTEGER)),
                 rexBuilder.makeExactLiteral(
                         new BigDecimal(Long.MAX_VALUE), FACTORY.createSqlType(SqlTypeName.BIGINT)),
-                rexBuilder.makeExactLiteral(
+                rexBuilder.makeApproxLiteral(
                         BigDecimal.valueOf(Double.MAX_VALUE),
                         FACTORY.createSqlType(SqlTypeName.DOUBLE)),
                 rexBuilder.makeApproxLiteral(
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/CalcTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/CalcTest.xml
index ec4dfbdbdafe8..3f77f12429dc9 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/CalcTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/CalcTest.xml
@@ -115,7 +115,7 @@ LogicalProject(EXPR$0=[$0], EXPR$1=[CAST($1):VARCHAR(2147483647) CHARACTER SET "
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a AS EXPR$0, CAST(b AS VARCHAR(2147483647)) AS EXPR$1])
+Calc(select=[3 AS EXPR$0, 'c' AS EXPR$1])
 +- Values(tuples=[[{ 3, _UTF-16LE'c' }]], values=[a, b])
 ]]>
     </Resource>
@@ -144,13 +144,13 @@ Calc(select=[a, b, c], where=[((a < 10) AND (b > 20))])
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[ARRAY(0.12:DECIMAL(3, 2), 0.5:DECIMAL(3, 2), 0.99:DECIMAL(3, 2))])
+LogicalProject(EXPR$0=[ARRAY(0.12:DECIMAL(3, 2), 0.50:DECIMAL(3, 2), 0.99:DECIMAL(3, 2))])
 +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[ARRAY(0.12, 0.5, 0.99) AS EXPR$0])
+Calc(select=[ARRAY(0.12, 0.50, 0.99) AS EXPR$0])
 +- Values(tuples=[[{ 0 }]], values=[ZERO])
 ]]>
     </Resource>
@@ -161,13 +161,13 @@ Calc(select=[ARRAY(0.12, 0.5, 0.99) AS EXPR$0])
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[MAP(_UTF-16LE'a', 0.12:DECIMAL(3, 2), _UTF-16LE'b', 0.5:DECIMAL(3, 2))])
+LogicalProject(EXPR$0=[MAP(_UTF-16LE'a', 0.12:DECIMAL(3, 2), _UTF-16LE'b', 0.50:DECIMAL(3, 2))])
 +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[MAP('a', 0.12, 'b', 0.5) AS EXPR$0])
+Calc(select=[MAP('a', 0.12, 'b', 0.50) AS EXPR$0])
 +- Values(tuples=[[{ 0 }]], values=[ZERO])
 ]]>
     </Resource>
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 464500c844aaa..14a58b5a56edb 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
@@ -467,10 +467,10 @@ LogicalProject(a=[$0], b=[$1], c=[$2], a0=[$3], b0=[$4], c0=[$5])
 +- LogicalFilter(condition=[=($2, $5)])
    +- LogicalJoin(condition=[true], joinType=[inner])
       :- LogicalProject(a=[MAX($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)], b=[$1], c=[$2])
-      :  +- LogicalProject(a=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST), null:INTEGER)], b=[$1], c=[$2])
+      :  +- LogicalProject(a=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST), null:INTEGER)], b=[$1], c=[$2])
       :     +- LogicalTableScan(table=[[default_catalog, default_database, x]])
       +- LogicalProject(a=[MIN($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)], b=[$1], c=[$2])
-         +- LogicalProject(a=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST), null:INTEGER)], b=[$1], c=[$2])
+         +- LogicalProject(a=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST), null:INTEGER)], b=[$1], c=[$2])
             +- LogicalTableScan(table=[[default_catalog, default_database, x]])
 ]]>
     </Resource>
@@ -483,7 +483,7 @@ HashJoin(joinType=[InnerJoin], where=[(c = c0)], select=[a, b, c, a0, b0, c0], b
 :        +- Exchange(distribution=[forward])
 :           +- Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS a, b, c])(reuse_id=[1])
 :              +- Exchange(distribution=[forward])
-:                 +- OverAggregate(partitionBy=[b], orderBy=[b ASC], window#0=[COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0, w0$o1])
+:                 +- OverAggregate(partitionBy=[b], orderBy=[b ASC], window#0=[COUNT(a) AS w0$o0, SUM(a) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0, w0$o1])
 :                    +- Exchange(distribution=[forward])
 :                       +- Sort(orderBy=[b ASC])
 :                          +- Exchange(distribution=[hash[b]])
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 2221630f38f31..1bfef026b4047 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
@@ -321,7 +321,7 @@ OverAggregate(orderBy=[b ASC], window#0=[RANK(*) AS w0$o0 RANGE BETWEEN UNBOUNDE
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0), 0), $SUM0($1) OVER (PARTITION BY $0), null:BIGINT), COUNT($1) OVER (PARTITION BY $0))], rn=[RANK() OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST)], c=[$0])
+LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0), 0), SUM($1) OVER (PARTITION BY $0), null:BIGINT), COUNT($1) OVER (PARTITION BY $0))], rn=[RANK() OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST)], c=[$0])
 +- LogicalAggregate(group=[{0}], sum_b=[SUM($1)])
    +- LogicalProject(c=[$2], b=[$1])
       +- LogicalTableScan(table=[[default_catalog, default_database, T]])
@@ -330,7 +330,7 @@ LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0), 0),
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[sum_b, (CASE((w0$o0 > 0), w0$o1, null:BIGINT) / w0$o0) AS avg_b, w1$o0 AS rn, c])
-+- OverAggregate(partitionBy=[c], window#0=[COUNT(sum_b) AS w0$o0, $SUM0(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[c, sum_b, w0$o0, w0$o1, w1$o0])
++- OverAggregate(partitionBy=[c], window#0=[COUNT(sum_b) AS w0$o0, SUM(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[c, sum_b, w0$o0, w0$o1, w1$o0])
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[c ASC])
          +- Exchange(distribution=[keep_input_as_is[hash[c]]])
@@ -378,7 +378,7 @@ OverAggregate(orderBy=[b ASC], window#0=[RANK(*) AS w0$o0 RANGE BETWEEN UNBOUNDE
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0), 0), $SUM0($1) OVER (PARTITION BY $0), null:BIGINT), COUNT($1) OVER (PARTITION BY $0))], rn=[RANK() OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST)], c=[$0])
+LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0), 0), SUM($1) OVER (PARTITION BY $0), null:BIGINT), COUNT($1) OVER (PARTITION BY $0))], rn=[RANK() OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST)], c=[$0])
 +- LogicalAggregate(group=[{0}], sum_b=[SUM($1)])
    +- LogicalProject(c=[$2], b=[$1])
       +- LogicalTableScan(table=[[default_catalog, default_database, T]])
@@ -387,7 +387,7 @@ LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0), 0),
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[sum_b, (CASE((w0$o0 > 0), w0$o1, null:BIGINT) / w0$o0) AS avg_b, w1$o0 AS rn, c])
-+- OverAggregate(partitionBy=[c], window#0=[COUNT(sum_b) AS w0$o0, $SUM0(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[c, sum_b, w0$o0, w0$o1, w1$o0])
++- OverAggregate(partitionBy=[c], window#0=[COUNT(sum_b) AS w0$o0, SUM(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[c, sum_b, w0$o0, w0$o1, w1$o0])
    +- Exchange(distribution=[forward])
       +- SortAggregate(isMerge=[true], groupBy=[c], select=[c, Final_SUM(sum$0) AS sum_b])
          +- Exchange(distribution=[forward])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/RemoveCollationTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/RemoveCollationTest.xml
index 5ed8902e1a878..3ec699250331d 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/RemoveCollationTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/RemoveCollationTest.xml
@@ -494,7 +494,7 @@ MultipleInput(members=[\nSortMergeJoin(joinType=[LeftOuterJoin], where=[((a1 = d
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST), 0), $SUM0($1) OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST), null:BIGINT), COUNT($1) OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST))], rn=[RANK() OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST)])
+LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST), 0), SUM($1) OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST), null:BIGINT), COUNT($1) OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST))], rn=[RANK() OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST)])
 +- LogicalAggregate(group=[{0}], sum_b=[SUM($1)])
    +- LogicalProject(a=[$0], b=[$1])
       +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]])
@@ -503,7 +503,7 @@ LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0 ORDER
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[sum_b, (CASE((w0$o0 > 0), w0$o1, null:BIGINT) / w0$o0) AS avg_b, w0$o2 AS rn])
-+- OverAggregate(partitionBy=[a], orderBy=[a ASC], window#0=[COUNT(sum_b) AS w0$o0, $SUM0(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#1=[RANK(*) AS w0$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, sum_b, w0$o0, w0$o1, w0$o2])
++- OverAggregate(partitionBy=[a], orderBy=[a ASC], window#0=[COUNT(sum_b) AS w0$o0, SUM(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#1=[RANK(*) AS w0$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, sum_b, w0$o0, w0$o1, w0$o2])
    +- Exchange(distribution=[forward])
       +- SortAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS sum_b])
          +- Exchange(distribution=[forward])
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 be2b0e58f2905..1b679021b32a8 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
@@ -552,7 +552,7 @@ HashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = cnt))], select=[a, b, c,
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(sum_b=[$2], avg_b=[/(CASE(>(COUNT($2) OVER (PARTITION BY $0, $1), 0), $SUM0($2) OVER (PARTITION BY $0, $1), null:BIGINT), COUNT($2) OVER (PARTITION BY $0, $1))], rn=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], c=[$1])
+LogicalProject(sum_b=[$2], avg_b=[/(CASE(>(COUNT($2) OVER (PARTITION BY $0, $1), 0), SUM($2) OVER (PARTITION BY $0, $1), null:BIGINT), COUNT($2) OVER (PARTITION BY $0, $1))], rn=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], c=[$1])
 +- LogicalAggregate(group=[{0, 1}], sum_b=[SUM($2)])
    +- LogicalProject(a=[$0], c=[$2], b=[$1])
       +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]])
@@ -565,7 +565,7 @@ Calc(select=[sum_b, (CASE((w0$o0 > 0), w0$o1, null:BIGINT) / w0$o0) AS avg_b, w1
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[c ASC, a ASC])
          +- Exchange(distribution=[hash[c]])
-            +- OverAggregate(partitionBy=[a, c], window#0=[COUNT(sum_b) AS w0$o0, $SUM0(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], select=[a, c, sum_b, w0$o0, w0$o1])
+            +- OverAggregate(partitionBy=[a, c], window#0=[COUNT(sum_b) AS w0$o0, SUM(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], select=[a, c, sum_b, w0$o0, w0$o1])
                +- Exchange(distribution=[forward])
                   +- Sort(orderBy=[a ASC, c ASC])
                      +- Exchange(distribution=[keep_input_as_is[hash[a, c]]])
@@ -630,7 +630,7 @@ MultipleInput(readOrder=[0,0,1], members=[\nNestedLoopJoin(joinType=[InnerJoin],
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0), 0), $SUM0($1) OVER (PARTITION BY $0), null:BIGINT), COUNT($1) OVER (PARTITION BY $0))], rn=[RANK() OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST)], c=[$0])
+LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0), 0), SUM($1) OVER (PARTITION BY $0), null:BIGINT), COUNT($1) OVER (PARTITION BY $0))], rn=[RANK() OVER (PARTITION BY $0 ORDER BY $0 NULLS FIRST)], c=[$0])
 +- LogicalAggregate(group=[{0}], sum_b=[SUM($1)])
    +- LogicalProject(c=[$2], b=[$1])
       +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]])
@@ -639,7 +639,7 @@ LogicalProject(sum_b=[$1], avg_b=[/(CASE(>(COUNT($1) OVER (PARTITION BY $0), 0),
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[sum_b, (CASE((w0$o0 > 0), w0$o1, null:BIGINT) / w0$o0) AS avg_b, w1$o0 AS rn, c])
-+- OverAggregate(partitionBy=[c], window#0=[COUNT(sum_b) AS w0$o0, $SUM0(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[c, sum_b, w0$o0, w0$o1, w1$o0])
++- OverAggregate(partitionBy=[c], window#0=[COUNT(sum_b) AS w0$o0, SUM(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[c, sum_b, w0$o0, w0$o1, w1$o0])
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[c ASC])
          +- Exchange(distribution=[keep_input_as_is[hash[c]]])
@@ -665,7 +665,7 @@ Calc(select=[sum_b, (CASE((w0$o0 > 0), w0$o1, null:BIGINT) / w0$o0) AS avg_b, w1
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(sum_b=[$2], avg_b=[/(CASE(>(COUNT($2) OVER (PARTITION BY $1), 0), $SUM0($2) OVER (PARTITION BY $1), null:BIGINT), COUNT($2) OVER (PARTITION BY $1))], rn=[RANK() OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)], c=[$1])
+LogicalProject(sum_b=[$2], avg_b=[/(CASE(>(COUNT($2) OVER (PARTITION BY $1), 0), SUM($2) OVER (PARTITION BY $1), null:BIGINT), COUNT($2) OVER (PARTITION BY $1))], rn=[RANK() OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)], c=[$1])
 +- LogicalAggregate(group=[{0, 1}], sum_b=[SUM($2)])
    +- LogicalProject(a=[$0], c=[$2], b=[$1])
       +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]])
@@ -674,7 +674,7 @@ LogicalProject(sum_b=[$2], avg_b=[/(CASE(>(COUNT($2) OVER (PARTITION BY $1), 0),
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[sum_b, (CASE((w0$o0 > 0), w0$o1, null:BIGINT) / w0$o0) AS avg_b, w1$o0 AS rn, c])
-+- OverAggregate(partitionBy=[c], window#0=[COUNT(sum_b) AS w0$o0, $SUM0(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[c, sum_b, w0$o0, w0$o1, w1$o0])
++- OverAggregate(partitionBy=[c], window#0=[COUNT(sum_b) AS w0$o0, SUM(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[c, sum_b, w0$o0, w0$o1, w1$o0])
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[c ASC])
          +- Exchange(distribution=[hash[c]])
@@ -1308,7 +1308,7 @@ HashAggregate(isMerge=[false], select=[MAX(b) AS EXPR$0])
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(sum_b=[$0], avg_b=[/(CASE(>(COUNT($0) OVER (), 0), $SUM0($0) OVER (), null:BIGINT), COUNT($0) OVER ())])
+LogicalProject(sum_b=[$0], avg_b=[/(CASE(>(COUNT($0) OVER (), 0), SUM($0) OVER (), null:BIGINT), COUNT($0) OVER ())])
 +- LogicalAggregate(group=[{}], sum_b=[SUM($0)])
    +- LogicalProject(b=[$1])
       +- LogicalTableScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]])
@@ -1317,7 +1317,7 @@ LogicalProject(sum_b=[$0], avg_b=[/(CASE(>(COUNT($0) OVER (), 0), $SUM0($0) OVER
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[sum_b, (CASE((w0$o0 > 0), w0$o1, null:BIGINT) / w0$o0) AS avg_b])
-+- OverAggregate(window#0=[COUNT(sum_b) AS w0$o0, $SUM0(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], select=[sum_b, w0$o0, w0$o1])
++- OverAggregate(window#0=[COUNT(sum_b) AS w0$o0, SUM(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], select=[sum_b, w0$o0, w0$o1])
    +- HashAggregate(isMerge=[true], select=[Final_SUM(sum$0) AS sum_b])
       +- Exchange(distribution=[single])
          +- LocalHashAggregate(select=[Partial_SUM(b) AS sum$0])
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 925122858d1a6..ce0755cf213d5 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
@@ -315,21 +315,21 @@ LogicalProject(c=[$0], e=[$1], avg_b=[$2], sum_b=[$3], psum=[$4], nsum=[$5], avg
       +- LogicalFilter(condition=[AND(=($3, $8), =($3, $13), =($4, $9), =($4, $14), =($2, +($7, 1)), =($2, -($12, 1)))])
          +- LogicalJoin(condition=[true], joinType=[inner])
             :- LogicalJoin(condition=[true], joinType=[inner])
-            :  :- LogicalProject(sum_b=[$2], avg_b=[/(CASE(>(COUNT($2) OVER (PARTITION BY $0, $1), 0), $SUM0($2) OVER (PARTITION BY $0, $1), null:BIGINT), COUNT($2) OVER (PARTITION BY $0, $1))], rn=[RANK() OVER (PARTITION BY $0, $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], c=[$0], e=[$1])
+            :  :- LogicalProject(sum_b=[$2], avg_b=[/(CASE(>(COUNT($2) OVER (PARTITION BY $0, $1), 0), SUM($2) OVER (PARTITION BY $0, $1), null:BIGINT), COUNT($2) OVER (PARTITION BY $0, $1))], rn=[RANK() OVER (PARTITION BY $0, $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], c=[$0], e=[$1])
             :  :  +- LogicalAggregate(group=[{0, 1}], sum_b=[SUM($2)])
             :  :     +- LogicalProject(c=[$2], e=[$4], b=[$1])
             :  :        +- LogicalFilter(condition=[AND(=($0, $3), IS NOT NULL($2), >($4, 10))])
             :  :           +- LogicalJoin(condition=[true], joinType=[inner])
             :  :              :- LogicalTableScan(table=[[default_catalog, default_database, x]])
             :  :              +- LogicalTableScan(table=[[default_catalog, default_database, y]])
-            :  +- LogicalProject(sum_b=[$2], avg_b=[/(CASE(>(COUNT($2) OVER (PARTITION BY $0, $1), 0), $SUM0($2) OVER (PARTITION BY $0, $1), null:BIGINT), COUNT($2) OVER (PARTITION BY $0, $1))], rn=[RANK() OVER (PARTITION BY $0, $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], c=[$0], e=[$1])
+            :  +- LogicalProject(sum_b=[$2], avg_b=[/(CASE(>(COUNT($2) OVER (PARTITION BY $0, $1), 0), SUM($2) OVER (PARTITION BY $0, $1), null:BIGINT), COUNT($2) OVER (PARTITION BY $0, $1))], rn=[RANK() OVER (PARTITION BY $0, $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], c=[$0], e=[$1])
             :     +- LogicalAggregate(group=[{0, 1}], sum_b=[SUM($2)])
             :        +- LogicalProject(c=[$2], e=[$4], b=[$1])
             :           +- LogicalFilter(condition=[AND(=($0, $3), IS NOT NULL($2), >($4, 10))])
             :              +- LogicalJoin(condition=[true], joinType=[inner])
             :                 :- LogicalTableScan(table=[[default_catalog, default_database, x]])
             :                 +- LogicalTableScan(table=[[default_catalog, default_database, y]])
-            +- LogicalProject(sum_b=[$2], avg_b=[/(CASE(>(COUNT($2) OVER (PARTITION BY $0, $1), 0), $SUM0($2) OVER (PARTITION BY $0, $1), null:BIGINT), COUNT($2) OVER (PARTITION BY $0, $1))], rn=[RANK() OVER (PARTITION BY $0, $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], c=[$0], e=[$1])
+            +- LogicalProject(sum_b=[$2], avg_b=[/(CASE(>(COUNT($2) OVER (PARTITION BY $0, $1), 0), SUM($2) OVER (PARTITION BY $0, $1), null:BIGINT), COUNT($2) OVER (PARTITION BY $0, $1))], rn=[RANK() OVER (PARTITION BY $0, $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], c=[$0], e=[$1])
                +- LogicalAggregate(group=[{0, 1}], sum_b=[SUM($2)])
                   +- LogicalProject(c=[$2], e=[$4], b=[$1])
                      +- LogicalFilter(condition=[AND(=($0, $3), IS NOT NULL($2), >($4, 10))])
@@ -344,7 +344,7 @@ Calc(select=[c, e, avg_b, sum_b, sum_b0 AS psum, sum_b1 AS nsum, avg_b0 AS avg_b
 +- MultipleInput(readOrder=[2,0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[((c = c0) AND (e = e0) AND (rn = $f5))], select=[sum_b, avg_b, rn, c, e, sum_b0, avg_b0, sum_b1, c0, e0, $f5], build=[left])\n:- Calc(select=[sum_b, avg_b, rn, c, e, sum_b0, avg_b0])\n:  +- HashJoin(joinType=[InnerJoin], where=[((c = c0) AND (e = e0) AND (rn = $f5))], select=[sum_b, avg_b, rn, c, e, sum_b0, avg_b0, c0, e0, $f5], build=[left])\n:     :- [#2] Exchange(distribution=[hash[c, e, rn]])\n:     +- [#3] Exchange(distribution=[hash[c, e, $f5]])\n+- [#1] Exchange(distribution=[hash[c, e, $f5]])\n])
    :- Exchange(distribution=[hash[c, e, $f5]])
    :  +- Calc(select=[sum_b, c, e, (w1$o0 - 1) AS $f5], where=[(c <> '')])
-   :     +- OverAggregate(partitionBy=[c, e], window#0=[COUNT(sum_b) AS w0$o0, $SUM0(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[c, e, sum_b, w0$o0, w0$o1, w1$o0])(reuse_id=[1])
+   :     +- OverAggregate(partitionBy=[c, e], window#0=[COUNT(sum_b) AS w0$o0, SUM(sum_b) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[c, e, sum_b, w0$o0, w0$o1, w1$o0])(reuse_id=[1])
    :        +- Exchange(distribution=[forward])
    :           +- Sort(orderBy=[c ASC, e ASC])
    :              +- Exchange(distribution=[keep_input_as_is[hash[c, e]]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/TableSinkTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/TableSinkTest.xml
index 9b802a0829235..a8821d0d5bfc9 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/TableSinkTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/TableSinkTest.xml
@@ -27,17 +27,19 @@ LogicalSink(table=[default_catalog.default_database.MyCtasSource], fields=[b, c,
 
 == Optimized Physical Plan ==
 Sink(table=[default_catalog.default_database.MyCtasSource], fields=[b, c, d])
-+- Calc(select=[b, c, d])
++- Calc(select=[1 AS b, 2 AS c, 'd1' AS d])
    +- Sort(orderBy=[a ASC])
       +- Exchange(distribution=[single])
-         +- Values(tuples=[[{ 1, 1, 2, _UTF-16LE'd1' }]], values=[a, b, c, d])
+         +- Calc(select=[1 AS b, 2 AS c, 'd1' AS d, 1 AS a])
+            +- Values(tuples=[[{ 1, 1, 2, _UTF-16LE'd1' }]], values=[a, b, c, d])
 
 == Optimized Execution Plan ==
 Sink(table=[default_catalog.default_database.MyCtasSource], fields=[b, c, d])
-+- Calc(select=[b, c, d])
++- Calc(select=[1 AS b, 2 AS c, 'd1' AS d])
    +- Sort(orderBy=[a ASC])
       +- Exchange(distribution=[single])
-         +- Values(tuples=[[{ 1, 1, 2, _UTF-16LE'd1' }]], values=[a, b, c, d])
+         +- Calc(select=[1 AS b, 2 AS c, 'd1' AS d, 1 AS a])
+            +- Values(tuples=[[{ 1, 1, 2, _UTF-16LE'd1' }]], values=[a, b, c, d])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/UnionTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/UnionTest.xml
index 7aa823d1c2361..875ffdff45c0c 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/UnionTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/UnionTest.xml
@@ -70,7 +70,7 @@ LogicalProject(a=[$0], b=[$1]), rowType=[RecordType(INTEGER a, DECIMAL(20, 1) b)
 +- LogicalUnion(all=[true]), rowType=[RecordType(INTEGER a, DECIMAL(20, 1) b)]
    :- LogicalProject(a=[$0], b=[$1]), rowType=[RecordType(INTEGER a, BIGINT b)]
    :  +- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]]), rowType=[RecordType(INTEGER a, BIGINT b, VARCHAR(2147483647) c)]
-   +- LogicalProject(a=[$0], EXPR$1=[0:DECIMAL(2, 1)]), rowType=[RecordType(INTEGER a, DECIMAL(2, 1) EXPR$1)]
+   +- LogicalProject(a=[$0], EXPR$1=[0.0:DECIMAL(2, 1)]), rowType=[RecordType(INTEGER a, DECIMAL(2, 1) EXPR$1)]
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]]), rowType=[RecordType(INTEGER a, BIGINT b, VARCHAR(2147483647) c)]
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ValuesTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ValuesTest.xml
index 8a1d0b9f3e3f0..089c876dea6c0 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ValuesTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ValuesTest.xml
@@ -118,7 +118,8 @@ LogicalProject(a=[$0], b=[$1], c=[$2])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Values(tuples=[[{ 1, 2, 3 }]], values=[a, b, c])
+Calc(select=[1 AS a, 2 AS b, 3 AS c])
++- Values(tuples=[[{ 1, 2, 3 }]], values=[a, b, c])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/agg/OverAggregateTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/agg/OverAggregateTest.xml
index 39f7ddd17a4ab..cef0bfe041034 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/agg/OverAggregateTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/agg/OverAggregateTest.xml
@@ -52,14 +52,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$0, w1$o0 AS EXPR$1, CAST((CASE((w2$o0 > 0), w2$o1, null:INTEGER) / w2$o0) AS INTEGER) AS EXPR$2, w0$o2 AS EXPR$3, w2$o2 AS EXPR$4])
-+- OverAggregate(partitionBy=[c], orderBy=[a ASC], window#0=[COUNT(a) AS w2$o0, $SUM0(a) AS w2$o1, MIN(a) AS w2$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0, w0$o1, w0$o2, w1$o0, w2$o0, w2$o1, w2$o2])
++- OverAggregate(partitionBy=[c], orderBy=[a ASC], window#0=[COUNT(a) AS w2$o0, SUM(a) AS w2$o1, MIN(a) AS w2$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0, w0$o1, w0$o2, w1$o0, w2$o0, w2$o1, w2$o2])
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[c ASC, a ASC])
          +- Exchange(distribution=[hash[c]])
@@ -67,7 +67,7 @@ Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$0, w1$o0 AS EXPR$1,
                +- Exchange(distribution=[forward])
                   +- Sort(orderBy=[b ASC, c ASC])
                      +- Exchange(distribution=[keep_input_as_is[hash[b]]])
-                        +- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#1=[RANK(*) AS w0$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0, w0$o1, w0$o2])
+                        +- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o0, SUM(a) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#1=[RANK(*) AS w0$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0, w0$o1, w0$o2])
                            +- Exchange(distribution=[forward])
                               +- Sort(orderBy=[b ASC, a ASC])
                                  +- Exchange(distribution=[hash[b]])
@@ -89,7 +89,7 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)], EXPR$2=[MIN($0) OVER (ORDER BY $2 NULLS FIRST, $0 NULLS FIRST)], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$4=[CAST(/(CASE(>(COUNT($0) OVER (ORDER BY $1 NULLS FIRST), 0), $SUM0($0) OVER (ORDER BY $1 NULLS FIRST), null:INTEGER), COUNT($0) OVER (ORDER BY $1 NULLS FIRST))):INTEGER])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)], EXPR$2=[MIN($0) OVER (ORDER BY $2 NULLS FIRST, $0 NULLS FIRST)], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$4=[CAST(/(CASE(>(COUNT($0) OVER (ORDER BY $1 NULLS FIRST), 0), SUM($0) OVER (ORDER BY $1 NULLS FIRST), null:INTEGER), COUNT($0) OVER (ORDER BY $1 NULLS FIRST))):INTEGER])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -100,7 +100,7 @@ Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$0, w1$o0 AS EXPR$1,
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[c ASC, a ASC])
          +- Exchange(distribution=[hash[c]])
-            +- OverAggregate(partitionBy=[b], orderBy=[c ASC], window#0=[COUNT(a) AS w3$o0, $SUM0(a) AS w3$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#1=[RANK(*) AS w2$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o2, w1$o0, w0$o1, w3$o0, w3$o1, w2$o0])
+            +- OverAggregate(partitionBy=[b], orderBy=[c ASC], window#0=[COUNT(a) AS w3$o0, SUM(a) AS w3$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#1=[RANK(*) AS w2$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o2, w1$o0, w0$o1, w3$o0, w3$o1, w2$o0])
                +- Exchange(distribution=[forward])
                   +- Sort(orderBy=[b ASC, c ASC])
                      +- Exchange(distribution=[hash[b]])
@@ -108,7 +108,7 @@ Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$0, w1$o0 AS EXPR$1,
                            +- Exchange(distribution=[forward])
                               +- Sort(orderBy=[c ASC, a ASC])
                                  +- Exchange(distribution=[forward])
-                                    +- OverAggregate(orderBy=[b ASC], window#0=[COUNT(a) AS w0$o2, $SUM0(a) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o2, w1$o0])
+                                    +- OverAggregate(orderBy=[b ASC], window#0=[COUNT(a) AS w0$o2, SUM(a) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o2, w1$o0])
                                        +- Sort(orderBy=[b ASC])
                                           +- Exchange(distribution=[single])
                                              +- TableSourceScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c])
@@ -126,7 +126,7 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -137,7 +137,7 @@ Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$0, w1$o0 AS EXPR$1])
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[c ASC, a ASC])
          +- Exchange(distribution=[hash[c]])
-            +- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0, w0$o1])
+            +- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o0, SUM(a) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0, w0$o1])
                +- Exchange(distribution=[forward])
                   +- Sort(orderBy=[b ASC, a ASC])
                      +- Exchange(distribution=[hash[b]])
@@ -159,7 +159,7 @@ SELECT
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[COUNT() OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN -1 PRECEDING AND 10 FOLLOWING)], EXPR$1=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$2=[RANK() OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST)], EXPR$3=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN 1 PRECEDING AND 10 FOLLOWING), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN 1 PRECEDING AND 10 FOLLOWING), null:INTEGER)], EXPR$4=[COUNT() OVER (PARTITION BY $2 ORDER BY $2 NULLS FIRST ROWS BETWEEN 1 PRECEDING AND 10 FOLLOWING)])
+LogicalProject(EXPR$0=[COUNT() OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN -1 PRECEDING AND 10 FOLLOWING)], EXPR$1=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$2=[RANK() OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST)], EXPR$3=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN 1 PRECEDING AND 10 FOLLOWING), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN 1 PRECEDING AND 10 FOLLOWING), null:INTEGER)], EXPR$4=[COUNT() OVER (PARTITION BY $2 ORDER BY $2 NULLS FIRST ROWS BETWEEN 1 PRECEDING AND 10 FOLLOWING)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -168,7 +168,7 @@ LogicalProject(EXPR$0=[COUNT() OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RAN
 Calc(select=[w0$o0 AS EXPR$0, CASE((w1$o0 > 0), w1$o1, null:INTEGER) AS EXPR$1, w2$o0 AS EXPR$2, CASE((w3$o0 > 0), w3$o1, null:INTEGER) AS EXPR$3, w4$o0 AS EXPR$4])
 +- OverAggregate(partitionBy=[c], orderBy=[c ASC], window#0=[COUNT(*) AS w4$o0 ROWS BETWEEN 1 PRECEDING AND 10 FOLLOWING], select=[a, c, w0$o0, w1$o0, w1$o1, w3$o1, w2$o0, w3$o0, w4$o0])
    +- Exchange(distribution=[forward])
-      +- OverAggregate(partitionBy=[c], orderBy=[a ASC], window#0=[COUNT(*) AS w0$o0 RANGE BETWEEN -1 PRECEDING AND 10 FOLLOWING], window#1=[COUNT(a) AS w1$o0, $SUM0(a) AS w1$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#2=[COUNT(a) AS w3$o1, $SUM0(a) AS w2$o0 RANGE BETWEEN 1 PRECEDING AND 10 FOLLOWING], window#3=[RANK(*) AS w3$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, w0$o0, w1$o0, w1$o1, w3$o1, w2$o0, w3$o0])
+      +- OverAggregate(partitionBy=[c], orderBy=[a ASC], window#0=[COUNT(*) AS w0$o0 RANGE BETWEEN -1 PRECEDING AND 10 FOLLOWING], window#1=[COUNT(a) AS w1$o0, SUM(a) AS w1$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#2=[COUNT(a) AS w3$o1, SUM(a) AS w2$o0 RANGE BETWEEN 1 PRECEDING AND 10 FOLLOWING], window#3=[RANK(*) AS w3$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, w0$o0, w1$o0, w1$o1, w3$o1, w2$o0, w3$o0])
          +- Exchange(distribution=[forward])
             +- Sort(orderBy=[c ASC, a ASC])
                +- Exchange(distribution=[hash[c]])
@@ -375,14 +375,14 @@ OverAggregate(partitionBy=[c], window#0=[COUNT(*) AS w0$o0 RANGE BETWEEN UNBOUND
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(c=[$2], EXPR$1=[CASE(>(COUNT($0) OVER (ORDER BY $1 NULLS FIRST), 0), $SUM0($0) OVER (ORDER BY $1 NULLS FIRST), null:INTEGER)])
+LogicalProject(c=[$2], EXPR$1=[CASE(>(COUNT($0) OVER (ORDER BY $1 NULLS FIRST), 0), SUM($0) OVER (ORDER BY $1 NULLS FIRST), null:INTEGER)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$1])
-+- OverAggregate(orderBy=[b ASC], window#0=[COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0, w0$o1])
++- OverAggregate(orderBy=[b ASC], window#0=[COUNT(a) AS w0$o0, SUM(a) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o0, w0$o1])
    +- Sort(orderBy=[b ASC])
       +- Exchange(distribution=[single])
          +- TableSourceScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c])
@@ -534,14 +534,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN -1 FOLLOWING AND 10 FOLLOWING), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN -1 FOLLOWING AND 10 FOLLOWING), null:INTEGER)], EXPR$1=[COUNT(1) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN -1 FOLLOWING AND 10 FOLLOWING)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN -1 FOLLOWING AND 10 FOLLOWING), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN -1 FOLLOWING AND 10 FOLLOWING), null:INTEGER)], EXPR$1=[COUNT(1) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN -1 FOLLOWING AND 10 FOLLOWING)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$0, w0$o2 AS EXPR$1])
-+- OverAggregate(partitionBy=[c], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1, COUNT(1) AS w0$o2 RANGE BETWEEN -1 FOLLOWING AND 10 FOLLOWING], select=[a, c, w0$o0, w0$o1, w0$o2])
++- OverAggregate(partitionBy=[c], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o0, SUM(a) AS w0$o1, COUNT(1) AS w0$o2 RANGE BETWEEN -1 FOLLOWING AND 10 FOLLOWING], select=[a, c, w0$o0, w0$o1, w0$o2])
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[c ASC, a ASC])
          +- Exchange(distribution=[hash[c]])
@@ -564,20 +564,20 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$0, w1$o0 AS EXPR$1, CAST((CASE((w2$o0 > 0), w2$o1, null:INTEGER) / w2$o0) AS INTEGER) AS EXPR$2, w0$o2 AS EXPR$3, w1$o1 AS EXPR$4])
-+- OverAggregate(partitionBy=[b], orderBy=[c ASC], window#0=[COUNT(a) AS w2$o0, $SUM0(a) AS w2$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o1, w0$o2, w1$o1, w0$o0, w2$o0, w2$o1, w1$o0])
++- OverAggregate(partitionBy=[b], orderBy=[c ASC], window#0=[COUNT(a) AS w2$o0, SUM(a) AS w2$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#1=[RANK(*) AS w1$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o1, w0$o2, w1$o1, w0$o0, w2$o0, w2$o1, w1$o0])
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[b ASC, c ASC])
          +- Exchange(distribution=[keep_input_as_is[hash[b]]])
             +- OverAggregate(partitionBy=[b], orderBy=[b ASC], window#0=[MAX(a) AS w1$o1, MIN(a) AS w0$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o1, w0$o2, w1$o1, w0$o0])
                +- Exchange(distribution=[forward])
-                  +- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o1, $SUM0(a) AS w0$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o1, w0$o2])
+                  +- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o1, SUM(a) AS w0$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w0$o1, w0$o2])
                      +- Exchange(distribution=[forward])
                         +- Sort(orderBy=[b ASC, a ASC])
                            +- Exchange(distribution=[hash[b]])
@@ -599,20 +599,20 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$0, w1$o0 AS EXPR$1, CAST((CASE((w2$o0 > 0), w2$o1, null:INTEGER) / w2$o0) AS INTEGER) AS EXPR$2, w3$o0 AS EXPR$3, w4$o0 AS EXPR$4])
-+- OverAggregate(partitionBy=[b], orderBy=[c ASC], window#0=[COUNT(a) AS w1$o0, $SUM0(a) AS w3$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w2$o0, w0$o0, w2$o1, w4$o0, w0$o1, w1$o0, w3$o0])
++- OverAggregate(partitionBy=[b], orderBy=[c ASC], window#0=[COUNT(a) AS w1$o0, SUM(a) AS w3$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w2$o0, w0$o0, w2$o1, w4$o0, w0$o1, w1$o0, w3$o0])
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[b ASC, c ASC])
          +- Exchange(distribution=[keep_input_as_is[hash[b]]])
             +- OverAggregate(partitionBy=[b], orderBy=[b ASC], window#0=[MIN(a) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w2$o0, w0$o0, w2$o1, w4$o0, w0$o1])
                +- Exchange(distribution=[forward])
-                  +- OverAggregate(partitionBy=[b], orderBy=[a ASC, c ASC], window#0=[COUNT(a) AS w2$o1, $SUM0(a) AS w4$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w2$o0, w0$o0, w2$o1, w4$o0])
+                  +- OverAggregate(partitionBy=[b], orderBy=[a ASC, c ASC], window#0=[COUNT(a) AS w2$o1, SUM(a) AS w4$o0 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, c, w2$o0, w0$o0, w2$o1, w4$o0])
                      +- Exchange(distribution=[forward])
                         +- Sort(orderBy=[b ASC, a ASC, c ASC])
                            +- Exchange(distribution=[keep_input_as_is[hash[b]]])
@@ -635,14 +635,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$0, w0$o2 AS EXPR$1])
-+- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1, MAX(a) AS w0$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0, w0$o1, w0$o2])
++- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o0, SUM(a) AS w0$o1, MAX(a) AS w0$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0, w0$o1, w0$o2])
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[b ASC, a ASC])
          +- Exchange(distribution=[hash[b]])
@@ -665,18 +665,18 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$0, w0$o2 AS EXPR$1, CAST((CASE((w1$o0 > 0), w1$o1, null:INTEGER) / w1$o0) AS INTEGER) AS EXPR$2, w0$o3 AS EXPR$3, w1$o2 AS EXPR$4])
-+- OverAggregate(partitionBy=[b], orderBy=[a DESC], window#0=[COUNT(a) AS w1$o0, $SUM0(a) AS w1$o1, MIN(a) AS w1$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0, w0$o1, w0$o2, w0$o3, w1$o0, w1$o1, w1$o2])
++- OverAggregate(partitionBy=[b], orderBy=[a DESC], window#0=[COUNT(a) AS w1$o0, SUM(a) AS w1$o1, MIN(a) AS w1$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0, w0$o1, w0$o2, w0$o3, w1$o0, w1$o1, w1$o2])
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[b ASC, a DESC])
          +- Exchange(distribution=[keep_input_as_is[hash[b]]])
-            +- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1, MAX(a) AS w0$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#1=[RANK(*) AS w0$o3 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0, w0$o1, w0$o2, w0$o3])
+            +- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w0$o0, SUM(a) AS w0$o1, MAX(a) AS w0$o2 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], window#1=[RANK(*) AS w0$o3 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o0, w0$o1, w0$o2, w0$o3])
                +- Exchange(distribution=[forward])
                   +- Sort(orderBy=[b ASC, a ASC])
                      +- Exchange(distribution=[hash[b]])
@@ -755,14 +755,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MIN($0) OVER (PARTITION BY $1)], EXPR$2=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MIN($0) OVER (PARTITION BY $1)], EXPR$2=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS EXPR$0, w1$o0 AS EXPR$1, w0$o2 AS EXPR$2])
-+- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w1$o0, $SUM0(a) AS w0$o0, MAX(a) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o2, w1$o0, w0$o0, w0$o1])
++- OverAggregate(partitionBy=[b], orderBy=[a ASC], window#0=[COUNT(a) AS w1$o0, SUM(a) AS w0$o0, MAX(a) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, b, w0$o2, w1$o0, w0$o0, w0$o1])
    +- Exchange(distribution=[forward])
       +- Sort(orderBy=[b ASC, a ASC])
          +- Exchange(distribution=[keep_input_as_is[hash[b]]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/AggregateReduceFunctionsRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/AggregateReduceFunctionsRuleTest.xml
index 5ef4da779a1ff..1e7bb904622ad 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/AggregateReduceFunctionsRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/AggregateReduceFunctionsRuleTest.xml
@@ -111,7 +111,7 @@ FROM src2 GROUP BY category]]>
     <Resource name="ast">
       <![CDATA[
 LogicalAggregate(group=[{0}], EXPR$1=[AVG($1)], EXPR$2=[VAR_POP($2)], EXPR$3=[STDDEV_SAMP($3)])
-+- LogicalProject(category=[$1], $f1=[+($2, $3)], $f2=[*($2, 2)], $f3=[CASE(>($2, 0), $2, 0:DOUBLE)])
++- LogicalProject(category=[$1], $f1=[+($2, $3)], $f2=[*($2, 2)], $f3=[CASE(>($2, 0), $2, 0.0E0:DOUBLE)])
    +- LogicalTableScan(table=[[default_catalog, default_database, src2]])
 ]]>
     </Resource>
@@ -120,7 +120,7 @@ LogicalAggregate(group=[{0}], EXPR$1=[AVG($1)], EXPR$2=[VAR_POP($2)], EXPR$3=[ST
 LogicalProject(category=[$0], EXPR$1=[/($1, $2)], EXPR$2=[/($3, $4)], EXPR$3=[POWER(/($5, CASE(=($6, 1), null:BIGINT, -($6, 1))), 0.5:DECIMAL(2, 1))])
 +- LogicalProject(category=[$0], $f1=[CASE(=($2, 0), null:DOUBLE, $1)], $f2=[$2], $f3=[$3], $f4=[$4], $f5=[$5], $f6=[$6])
    +- LogicalAggregate(group=[{0}], agg#0=[$SUM0($1)], agg#1=[COUNT($1)], agg#2=[$WELFORD_M2$1($2)], agg#3=[COUNT($2)], agg#4=[$WELFORD_M2$1($3)], agg#5=[COUNT($3)])
-      +- LogicalProject(category=[$1], $f1=[+($2, $3)], $f2=[*($2, 2)], $f3=[CASE(>($2, 0), $2, 0:DOUBLE)])
+      +- LogicalProject(category=[$1], $f1=[+($2, $3)], $f2=[*($2, 2)], $f3=[CASE(>($2, 0), $2, 0.0E0:DOUBLE)])
          +- LogicalTableScan(table=[[default_catalog, default_database, src2]])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ConvertToNotInOrInRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ConvertToNotInOrInRuleTest.xml
index 8f8128fb4a6c3..50c3c824995d3 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ConvertToNotInOrInRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ConvertToNotInOrInRuleTest.xml
@@ -61,14 +61,14 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
-+- LogicalFilter(condition=[OR(=($1, 1), =($1, 2), AND(<>($0, 1), <>($0, 2), <>($0, 3), <>($0, 4), =($2, 1)), =($1, 3), =($1, 4), =($2, 1))])
++- LogicalFilter(condition=[OR(=($1, 1), =($1, 2), AND(<>($0, 1), <>($0, 2), <>($0, 3), <>($0, 4), =($2, CAST(1):FLOAT NOT NULL)), =($1, 3), =($1, 4), =($2, CAST(1):FLOAT NOT NULL))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
-+- LogicalFilter(condition=[OR(AND(=($2, 1), NOT(SEARCH($0, Sarg[1, 2, 3, 4]))), SEARCH($1, Sarg[1L:BIGINT, 2L:BIGINT, 3L:BIGINT, 4L:BIGINT]:BIGINT), =($2, 1))])
++- LogicalFilter(condition=[OR(AND(=($2, CAST(1):FLOAT NOT NULL), NOT(SEARCH($0, Sarg[1, 2, 3, 4]))), =($2, CAST(1):FLOAT NOT NULL), SEARCH($1, Sarg[1L:BIGINT, 2L:BIGINT, 3L:BIGINT, 4L:BIGINT]:BIGINT))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -99,14 +99,14 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
-+- LogicalFilter(condition=[OR(=($3, 1), =($3, 2), =($3, 3), =($3, 4), =($3, 5), =($3, 6), =($3, 7), =($3, 8), =($3, 9), =($3, 10), =($3, 11), =($3, 12), =($3, 13), =($3, 14), =($3, 15), =($3, 16), =($3, 17), =($3, 18), =($3, 19), =($3, 20))])
++- LogicalFilter(condition=[OR(=($3, CAST(1):DOUBLE NOT NULL), =($3, CAST(2):DOUBLE NOT NULL), =($3, CAST(3):DOUBLE NOT NULL), =($3, CAST(4):DOUBLE NOT NULL), =($3, CAST(5):DOUBLE NOT NULL), =($3, CAST(6):DOUBLE NOT NULL), =($3, CAST(7):DOUBLE NOT NULL), =($3, CAST(8):DOUBLE NOT NULL), =($3, CAST(9):DOUBLE NOT NULL), =($3, CAST(10):DOUBLE NOT NULL), =($3, CAST(11):DOUBLE NOT NULL), =($3, CAST(12):DOUBLE NOT NULL), =($3, CAST(13):DOUBLE NOT NULL), =($3, CAST(14):DOUBLE NOT NULL), =($3, CAST(15):DOUBLE NOT NULL), =($3, CAST(16):DOUBLE NOT NULL), =($3, CAST(17):DOUBLE NOT NULL), =($3, CAST(18):DOUBLE NOT NULL), =($3, CAST(19):DOUBLE NOT NULL), =($3, CAST(20):DOUBLE NOT NULL))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
-+- LogicalFilter(condition=[SEARCH($3, Sarg[1E0:DOUBLE, 2E0:DOUBLE, 3E0:DOUBLE, 4E0:DOUBLE, 5E0:DOUBLE, 6E0:DOUBLE, 7E0:DOUBLE, 8E0:DOUBLE, 9E0:DOUBLE, 1E1:DOUBLE, 1.1E1:DOUBLE, 1.2E1:DOUBLE, 1.3E1:DOUBLE, 1.4E1:DOUBLE, 1.5E1:DOUBLE, 1.6E1:DOUBLE, 1.7E1:DOUBLE, 1.8E1:DOUBLE, 1.9E1:DOUBLE, 2E1:DOUBLE]:DOUBLE)])
++- LogicalFilter(condition=[OR(=($3, CAST(1):DOUBLE NOT NULL), =($3, CAST(2):DOUBLE NOT NULL), =($3, CAST(3):DOUBLE NOT NULL), =($3, CAST(4):DOUBLE NOT NULL), =($3, CAST(5):DOUBLE NOT NULL), =($3, CAST(6):DOUBLE NOT NULL), =($3, CAST(7):DOUBLE NOT NULL), =($3, CAST(8):DOUBLE NOT NULL), =($3, CAST(9):DOUBLE NOT NULL), =($3, CAST(10):DOUBLE NOT NULL), =($3, CAST(11):DOUBLE NOT NULL), =($3, CAST(12):DOUBLE NOT NULL), =($3, CAST(13):DOUBLE NOT NULL), =($3, CAST(14):DOUBLE NOT NULL), =($3, CAST(15):DOUBLE NOT NULL), =($3, CAST(16):DOUBLE NOT NULL), =($3, CAST(17):DOUBLE NOT NULL), =($3, CAST(18):DOUBLE NOT NULL), =($3, CAST(19):DOUBLE NOT NULL), =($3, CAST(20):DOUBLE NOT NULL))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -137,14 +137,14 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
-+- LogicalFilter(condition=[OR(=($3, 1), =($3, 2), =($3, 3), =($3, 4), =($3, 5), =($3, 6), =($3, 7), =($3, 8), =($3, 9), =($3, 10), =($3, 11), =($3, 12), =($3, 13), =($3, 14), =($3, 15), =($3, 16), =($3, 17), =($3, 18), =($3, 19))])
++- LogicalFilter(condition=[OR(=($3, CAST(1):DOUBLE NOT NULL), =($3, CAST(2):DOUBLE NOT NULL), =($3, CAST(3):DOUBLE NOT NULL), =($3, CAST(4):DOUBLE NOT NULL), =($3, CAST(5):DOUBLE NOT NULL), =($3, CAST(6):DOUBLE NOT NULL), =($3, CAST(7):DOUBLE NOT NULL), =($3, CAST(8):DOUBLE NOT NULL), =($3, CAST(9):DOUBLE NOT NULL), =($3, CAST(10):DOUBLE NOT NULL), =($3, CAST(11):DOUBLE NOT NULL), =($3, CAST(12):DOUBLE NOT NULL), =($3, CAST(13):DOUBLE NOT NULL), =($3, CAST(14):DOUBLE NOT NULL), =($3, CAST(15):DOUBLE NOT NULL), =($3, CAST(16):DOUBLE NOT NULL), =($3, CAST(17):DOUBLE NOT NULL), =($3, CAST(18):DOUBLE NOT NULL), =($3, CAST(19):DOUBLE NOT NULL))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
-+- LogicalFilter(condition=[OR(=($3, 1), =($3, 2), =($3, 3), =($3, 4), =($3, 5), =($3, 6), =($3, 7), =($3, 8), =($3, 9), =($3, 10), =($3, 11), =($3, 12), =($3, 13), =($3, 14), =($3, 15), =($3, 16), =($3, 17), =($3, 18), =($3, 19))])
++- LogicalFilter(condition=[OR(=($3, CAST(1):DOUBLE NOT NULL), =($3, CAST(2):DOUBLE NOT NULL), =($3, CAST(3):DOUBLE NOT NULL), =($3, CAST(4):DOUBLE NOT NULL), =($3, CAST(5):DOUBLE NOT NULL), =($3, CAST(6):DOUBLE NOT NULL), =($3, CAST(7):DOUBLE NOT NULL), =($3, CAST(8):DOUBLE NOT NULL), =($3, CAST(9):DOUBLE NOT NULL), =($3, CAST(10):DOUBLE NOT NULL), =($3, CAST(11):DOUBLE NOT NULL), =($3, CAST(12):DOUBLE NOT NULL), =($3, CAST(13):DOUBLE NOT NULL), =($3, CAST(14):DOUBLE NOT NULL), =($3, CAST(15):DOUBLE NOT NULL), =($3, CAST(16):DOUBLE NOT NULL), =($3, CAST(17):DOUBLE NOT NULL), =($3, CAST(18):DOUBLE NOT NULL), =($3, CAST(19):DOUBLE NOT NULL))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -270,14 +270,14 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
-+- LogicalFilter(condition=[AND(<>($3, 1), <>($3, 2), <>($3, 3), <>($3, 4), <>($3, 5), <>($3, 6), <>($3, 7), <>($3, 8), <>($3, 9), <>($3, 10), <>($3, 11), <>($3, 12), <>($3, 13), <>($3, 14), <>($3, 15), <>($3, 16), <>($3, 17), <>($3, 18), <>($3, 19), <>($3, 20))])
++- LogicalFilter(condition=[AND(<>($3, CAST(1):DOUBLE NOT NULL), <>($3, CAST(2):DOUBLE NOT NULL), <>($3, CAST(3):DOUBLE NOT NULL), <>($3, CAST(4):DOUBLE NOT NULL), <>($3, CAST(5):DOUBLE NOT NULL), <>($3, CAST(6):DOUBLE NOT NULL), <>($3, CAST(7):DOUBLE NOT NULL), <>($3, CAST(8):DOUBLE NOT NULL), <>($3, CAST(9):DOUBLE NOT NULL), <>($3, CAST(10):DOUBLE NOT NULL), <>($3, CAST(11):DOUBLE NOT NULL), <>($3, CAST(12):DOUBLE NOT NULL), <>($3, CAST(13):DOUBLE NOT NULL), <>($3, CAST(14):DOUBLE NOT NULL), <>($3, CAST(15):DOUBLE NOT NULL), <>($3, CAST(16):DOUBLE NOT NULL), <>($3, CAST(17):DOUBLE NOT NULL), <>($3, CAST(18):DOUBLE NOT NULL), <>($3, CAST(19):DOUBLE NOT NULL), <>($3, CAST(20):DOUBLE NOT NULL))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
-+- LogicalFilter(condition=[NOT(SEARCH($3, Sarg[1E0:DOUBLE, 2E0:DOUBLE, 3E0:DOUBLE, 4E0:DOUBLE, 5E0:DOUBLE, 6E0:DOUBLE, 7E0:DOUBLE, 8E0:DOUBLE, 9E0:DOUBLE, 1E1:DOUBLE, 1.1E1:DOUBLE, 1.2E1:DOUBLE, 1.3E1:DOUBLE, 1.4E1:DOUBLE, 1.5E1:DOUBLE, 1.6E1:DOUBLE, 1.7E1:DOUBLE, 1.8E1:DOUBLE, 1.9E1:DOUBLE, 2E1:DOUBLE]:DOUBLE))])
++- LogicalFilter(condition=[AND(<>($3, CAST(1):DOUBLE NOT NULL), <>($3, CAST(2):DOUBLE NOT NULL), <>($3, CAST(3):DOUBLE NOT NULL), <>($3, CAST(4):DOUBLE NOT NULL), <>($3, CAST(5):DOUBLE NOT NULL), <>($3, CAST(6):DOUBLE NOT NULL), <>($3, CAST(7):DOUBLE NOT NULL), <>($3, CAST(8):DOUBLE NOT NULL), <>($3, CAST(9):DOUBLE NOT NULL), <>($3, CAST(10):DOUBLE NOT NULL), <>($3, CAST(11):DOUBLE NOT NULL), <>($3, CAST(12):DOUBLE NOT NULL), <>($3, CAST(13):DOUBLE NOT NULL), <>($3, CAST(14):DOUBLE NOT NULL), <>($3, CAST(15):DOUBLE NOT NULL), <>($3, CAST(16):DOUBLE NOT NULL), <>($3, CAST(17):DOUBLE NOT NULL), <>($3, CAST(18):DOUBLE NOT NULL), <>($3, CAST(19):DOUBLE NOT NULL), <>($3, CAST(20):DOUBLE NOT NULL))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -308,14 +308,14 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
-+- LogicalFilter(condition=[AND(<>($3, 1), <>($3, 2), <>($3, 3), <>($3, 4), <>($3, 5), <>($3, 6), <>($3, 7), <>($3, 8), <>($3, 9), <>($3, 10), <>($3, 11), <>($3, 12), <>($3, 13), <>($3, 14), <>($3, 15), <>($3, 16), <>($3, 17), <>($3, 18), <>($3, 19))])
++- LogicalFilter(condition=[AND(<>($3, CAST(1):DOUBLE NOT NULL), <>($3, CAST(2):DOUBLE NOT NULL), <>($3, CAST(3):DOUBLE NOT NULL), <>($3, CAST(4):DOUBLE NOT NULL), <>($3, CAST(5):DOUBLE NOT NULL), <>($3, CAST(6):DOUBLE NOT NULL), <>($3, CAST(7):DOUBLE NOT NULL), <>($3, CAST(8):DOUBLE NOT NULL), <>($3, CAST(9):DOUBLE NOT NULL), <>($3, CAST(10):DOUBLE NOT NULL), <>($3, CAST(11):DOUBLE NOT NULL), <>($3, CAST(12):DOUBLE NOT NULL), <>($3, CAST(13):DOUBLE NOT NULL), <>($3, CAST(14):DOUBLE NOT NULL), <>($3, CAST(15):DOUBLE NOT NULL), <>($3, CAST(16):DOUBLE NOT NULL), <>($3, CAST(17):DOUBLE NOT NULL), <>($3, CAST(18):DOUBLE NOT NULL), <>($3, CAST(19):DOUBLE NOT NULL))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
-+- LogicalFilter(condition=[AND(<>($3, 1), <>($3, 2), <>($3, 3), <>($3, 4), <>($3, 5), <>($3, 6), <>($3, 7), <>($3, 8), <>($3, 9), <>($3, 10), <>($3, 11), <>($3, 12), <>($3, 13), <>($3, 14), <>($3, 15), <>($3, 16), <>($3, 17), <>($3, 18), <>($3, 19))])
++- LogicalFilter(condition=[AND(<>($3, CAST(1):DOUBLE NOT NULL), <>($3, CAST(2):DOUBLE NOT NULL), <>($3, CAST(3):DOUBLE NOT NULL), <>($3, CAST(4):DOUBLE NOT NULL), <>($3, CAST(5):DOUBLE NOT NULL), <>($3, CAST(6):DOUBLE NOT NULL), <>($3, CAST(7):DOUBLE NOT NULL), <>($3, CAST(8):DOUBLE NOT NULL), <>($3, CAST(9):DOUBLE NOT NULL), <>($3, CAST(10):DOUBLE NOT NULL), <>($3, CAST(11):DOUBLE NOT NULL), <>($3, CAST(12):DOUBLE NOT NULL), <>($3, CAST(13):DOUBLE NOT NULL), <>($3, CAST(14):DOUBLE NOT NULL), <>($3, CAST(15):DOUBLE NOT NULL), <>($3, CAST(16):DOUBLE NOT NULL), <>($3, CAST(17):DOUBLE NOT NULL), <>($3, CAST(18):DOUBLE NOT NULL), <>($3, CAST(19):DOUBLE NOT NULL))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -459,7 +459,7 @@ LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2], d=[$3], e=[$4])
-+- LogicalFilter(condition=[SEARCH($4, Sarg[_UTF-16LE'CTNBSmokeSensor':VARCHAR(15) CHARACTER SET "UTF-16LE", _UTF-16LE'DH-9908N':VARCHAR(15) CHARACTER SET "UTF-16LE", _UTF-16LE'DH-9908N-AEP':VARCHAR(15) CHARACTER SET "UTF-16LE", _UTF-16LE'GHL-IRD':VARCHAR(15) CHARACTER SET "UTF-16LE", _UTF-16LE'H388N':VARCHAR(15) CHARACTER SET "UTF-16LE", _UTF-16LE'H389N     ':VARCHAR(15) CHARACTER SET "UTF-16LE", _UTF-16LE'HC809':VARCHAR(15) CHARACTER SET "UTF-16LE", _UTF-16LE'JY-BF-20YN':VARCHAR(15) CHARACTER SET "UTF-16LE"]:VARCHAR(15) CHARACTER SET "UTF-16LE")])
++- LogicalFilter(condition=[SEARCH($4, Sarg[_UTF-16LE'CTNBSmokeSensor':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'DH-9908N':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'DH-9908N-AEP':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'GHL-IRD':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'H388N':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'H389N     ':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'HC809':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'JY-BF-20YN':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"]:VARCHAR(2147483647) CHARACTER SET "UTF-16LE")])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/FlinkPruneEmptyRulesTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/FlinkPruneEmptyRulesTest.xml
index abf88a5994a9c..10846be548f33 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/FlinkPruneEmptyRulesTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/FlinkPruneEmptyRulesTest.xml
@@ -152,7 +152,13 @@ LogicalMinus(all=[false])
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
-LogicalValues(tuples=[[]])
+LogicalMinus(all=[false])
+:- LogicalMinus(all=[false])
+:  :- LogicalValues(tuples=[[]])
+:  +- LogicalProject(EXPR$0=[20], EXPR$1=[2])
+:     +- LogicalValues(tuples=[[{ 20, 2 }]])
++- LogicalProject(EXPR$0=[40], EXPR$1=[4])
+   +- LogicalValues(tuples=[[{ 40, 4 }]])
 ]]>
     </Resource>
   </TestCase>
@@ -188,10 +194,14 @@ LogicalMinus(all=[false])
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalMinus(all=[false])
-:- LogicalProject(x=[$0], y=[$1])
-:  +- LogicalValues(tuples=[[{ 30, 3 }]])
-+- LogicalProject(EXPR$0=[$0], EXPR$1=[$1])
-   +- LogicalValues(tuples=[[{ 40, 4 }]])
+:- LogicalMinus(all=[false])
+:  :- LogicalMinus(all=[false])
+:  :  :- LogicalProject(x=[30], y=[3])
+:  :  :  +- LogicalValues(tuples=[[{ 30, 3 }]])
+:  :  +- LogicalValues(tuples=[[]])
+:  +- LogicalProject(EXPR$0=[40], EXPR$1=[4])
+:     +- LogicalValues(tuples=[[{ 40, 4 }]])
++- LogicalValues(tuples=[[]])
 ]]>
     </Resource>
   </TestCase>
@@ -215,9 +225,10 @@ LogicalMinus(all=[false])
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
-LogicalAggregate(group=[{0, 1}])
-+- LogicalProject(X=[$0], Y=[$1])
-   +- LogicalValues(tuples=[[{ 30, 3 }, { 30, 3 }]])
+LogicalMinus(all=[false])
+:- LogicalProject(X=[30], Y=[3])
+:  +- LogicalValues(tuples=[[{ 30, 3 }, { 30, 3 }]])
++- LogicalValues(tuples=[[]])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/PushFilterIntoTableSourceScanRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/PushFilterIntoTableSourceScanRuleTest.xml
index a3aaacbd1e159..3f68f46432f2a 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/PushFilterIntoTableSourceScanRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/PushFilterIntoTableSourceScanRuleTest.xml
@@ -163,7 +163,7 @@ LogicalProject(name=[$0], id=[$1], amount=[$2], price=[$3])
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(name=[$0], id=[$1], amount=[$2], price=[$3])
-+- LogicalFilter(condition=[SEARCH($0, Sarg[_UTF-16LE'Alice':VARCHAR(5) CHARACTER SET "UTF-16LE", _UTF-16LE'Bob':VARCHAR(5) CHARACTER SET "UTF-16LE", _UTF-16LE'Dave':VARCHAR(5) CHARACTER SET "UTF-16LE"]:VARCHAR(5) CHARACTER SET "UTF-16LE")])
++- LogicalFilter(condition=[SEARCH($0, Sarg[_UTF-16LE'Alice':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Bob':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Dave':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"]:VARCHAR(2147483647) CHARACTER SET "UTF-16LE")])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable, filter=[]]])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/RemoveUnreachableCoalesceArgumentsRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/RemoveUnreachableCoalesceArgumentsRuleTest.xml
index 1003f2fdbef7d..53b4c0dbb2a73 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/RemoveUnreachableCoalesceArgumentsRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/RemoveUnreachableCoalesceArgumentsRuleTest.xml
@@ -134,13 +134,13 @@ COALESCE(cast(NULL as double), cast(NULL as double))]]>
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[1], EXPR$1=[1], EXPR$2=[2], EXPR$3=[1], EXPR$4=[3], EXPR$5=[4], EXPR$6=[_UTF-16LE'1'], EXPR$7=[_UTF-16LE'1':VARCHAR(2) CHARACTER SET "UTF-16LE"], EXPR$8=[_UTF-16LE'2':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"], EXPR$9=[_UTF-16LE'1':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"], EXPR$10=[_UTF-16LE'3':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"], EXPR$11=[_UTF-16LE'4':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"], EXPR$12=[1.0:DECIMAL(2, 1)], EXPR$13=[1.0:DECIMAL(11, 1)], EXPR$14=[2.0:DOUBLE], EXPR$15=[2.0:DOUBLE], EXPR$16=[2.0:DOUBLE], EXPR$17=[null:DOUBLE])
+LogicalProject(EXPR$0=[1], EXPR$1=[1], EXPR$2=[2], EXPR$3=[1], EXPR$4=[3], EXPR$5=[4], EXPR$6=[_UTF-16LE'1'], EXPR$7=[_UTF-16LE'1':VARCHAR(2) CHARACTER SET "UTF-16LE"], EXPR$8=[_UTF-16LE'2':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"], EXPR$9=[_UTF-16LE'1':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"], EXPR$10=[_UTF-16LE'3':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"], EXPR$11=[_UTF-16LE'4':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"], EXPR$12=[1.0:DECIMAL(2, 1)], EXPR$13=[1.0:DECIMAL(11, 1)], EXPR$14=[CAST(2.0:DECIMAL(2, 1)):DOUBLE NOT NULL], EXPR$15=[CAST(2.0:DECIMAL(2, 1)):DOUBLE NOT NULL], EXPR$16=[CAST(2.0:DECIMAL(2, 1)):DOUBLE NOT NULL], EXPR$17=[null:DOUBLE])
 +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
-Calc(select=[1 AS EXPR$0, 1 AS EXPR$1, 2 AS EXPR$2, 1 AS EXPR$3, 3 AS EXPR$4, 4 AS EXPR$5, '1' AS EXPR$6, '1' AS EXPR$7, '2' AS EXPR$8, '1' AS EXPR$9, '3' AS EXPR$10, '4' AS EXPR$11, 1.0 AS EXPR$12, 1.0 AS EXPR$13, 2.0 AS EXPR$14, 2.0 AS EXPR$15, 2.0 AS EXPR$16, null:DOUBLE AS EXPR$17])
+Calc(select=[1 AS EXPR$0, 1 AS EXPR$1, 2 AS EXPR$2, 1 AS EXPR$3, 3 AS EXPR$4, 4 AS EXPR$5, '1' AS EXPR$6, '1' AS EXPR$7, '2' AS EXPR$8, '1' AS EXPR$9, '3' AS EXPR$10, '4' AS EXPR$11, 1.0 AS EXPR$12, 1.0 AS EXPR$13, 2.0E0 AS EXPR$14, 2.0E0 AS EXPR$15, 2.0E0 AS EXPR$16, null:DOUBLE AS EXPR$17])
 +- Values(tuples=[[{ 0 }]])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/WindowGroupReorderRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/WindowGroupReorderRuleTest.xml
index bcd2d7dd414ff..6f52e40e10da6 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/WindowGroupReorderRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/WindowGroupReorderRuleTest.xml
@@ -30,14 +30,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(EXPR$0=[CASE(>($3, 0), $4, null:INTEGER)], EXPR$1=[$6], EXPR$2=[CAST(/(CASE(>($7, 0), $8, null:INTEGER), $7)):INTEGER], EXPR$3=[$5], EXPR$4=[$9])
-+- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), $SUM0($0), RANK()])], window#1=[window(partition {1} order by [2 ASC-nulls-first] aggs [MAX($0)])], window#2=[window(partition {2} order by [0 ASC-nulls-first] aggs [COUNT($0), $SUM0($0), MIN($0)])])
++- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), SUM($0), RANK()])], window#1=[window(partition {1} order by [2 ASC-nulls-first] aggs [MAX($0)])], window#2=[window(partition {2} order by [0 ASC-nulls-first] aggs [COUNT($0), SUM($0), MIN($0)])])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -56,14 +56,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)], EXPR$2=[MIN($0) OVER (ORDER BY $2 NULLS FIRST, $0 NULLS FIRST)], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$4=[CAST(/(CASE(>(COUNT($0) OVER (ORDER BY $1 NULLS FIRST), 0), $SUM0($0) OVER (ORDER BY $1 NULLS FIRST), null:INTEGER), COUNT($0) OVER (ORDER BY $1 NULLS FIRST))):INTEGER])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)], EXPR$2=[MIN($0) OVER (ORDER BY $2 NULLS FIRST, $0 NULLS FIRST)], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$4=[CAST(/(CASE(>(COUNT($0) OVER (ORDER BY $1 NULLS FIRST), 0), SUM($0) OVER (ORDER BY $1 NULLS FIRST), null:INTEGER), COUNT($0) OVER (ORDER BY $1 NULLS FIRST))):INTEGER])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(EXPR$0=[CASE(>($6, 0), $7, null:INTEGER)], EXPR$1=[$9], EXPR$2=[$5], EXPR$3=[$8], EXPR$4=[CAST(/(CASE(>($3, 0), $4, null:INTEGER), $3)):INTEGER])
-+- LogicalWindow(window#0=[window(order by [1 ASC-nulls-first] aggs [COUNT($0), $SUM0($0)])], window#1=[window(order by [2 ASC-nulls-first, 0 ASC-nulls-first] aggs [MIN($0)])], window#2=[window(partition {1} order by [2 ASC-nulls-first] aggs [COUNT($0), $SUM0($0), RANK()])], window#3=[window(partition {2} order by [0 ASC-nulls-first] aggs [MAX($0)])])
++- LogicalWindow(window#0=[window(order by [1 ASC-nulls-first] aggs [COUNT($0), SUM($0)])], window#1=[window(order by [2 ASC-nulls-first, 0 ASC-nulls-first] aggs [MIN($0)])], window#2=[window(partition {1} order by [2 ASC-nulls-first] aggs [COUNT($0), SUM($0), RANK()])], window#3=[window(partition {2} order by [0 ASC-nulls-first] aggs [MAX($0)])])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -82,14 +82,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(EXPR$0=[CASE(>($3, 0), $4, null:INTEGER)], EXPR$1=[$5], EXPR$2=[CAST(/(CASE(>($7, 0), $8, null:INTEGER), $7)):INTEGER], EXPR$3=[$6], EXPR$4=[$9])
-+- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), $SUM0($0), MAX($0), RANK()])], window#1=[window(partition {2} order by [0 ASC-nulls-first] aggs [COUNT($0), $SUM0($0), MIN($0)])])
++- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), SUM($0), MAX($0), RANK()])], window#1=[window(partition {2} order by [0 ASC-nulls-first] aggs [COUNT($0), SUM($0), MIN($0)])])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -108,14 +108,14 @@ SELECT
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[COUNT() OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN -1 PRECEDING AND 10 FOLLOWING)], EXPR$1=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$2=[RANK() OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST)], EXPR$3=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN 1 PRECEDING AND 10 FOLLOWING), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN 1 PRECEDING AND 10 FOLLOWING), null:INTEGER)], EXPR$4=[COUNT() OVER (PARTITION BY $2 ORDER BY $2 NULLS FIRST ROWS BETWEEN 1 PRECEDING AND 10 FOLLOWING)])
+LogicalProject(EXPR$0=[COUNT() OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN -1 PRECEDING AND 10 FOLLOWING)], EXPR$1=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$2=[RANK() OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST)], EXPR$3=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN 1 PRECEDING AND 10 FOLLOWING), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RANGE BETWEEN 1 PRECEDING AND 10 FOLLOWING), null:INTEGER)], EXPR$4=[COUNT() OVER (PARTITION BY $2 ORDER BY $2 NULLS FIRST ROWS BETWEEN 1 PRECEDING AND 10 FOLLOWING)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(EXPR$0=[$2], EXPR$1=[CASE(>($3, 0), $4, null:INTEGER)], EXPR$2=[$7], EXPR$3=[CASE(>($5, 0), $6, null:INTEGER)], EXPR$4=[$8])
-+- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] range between $2 PRECEDING and $3 FOLLOWING aggs [COUNT()])], window#1=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), $SUM0($0)])], window#2=[window(partition {1} order by [0 ASC-nulls-first] range between $4 PRECEDING and $3 FOLLOWING aggs [COUNT($0), $SUM0($0)])], window#3=[window(partition {1} order by [0 ASC-nulls-first, 1 ASC-nulls-first] aggs [RANK()])], window#4=[window(partition {1} order by [1 ASC-nulls-first] rows between $4 PRECEDING and $3 FOLLOWING aggs [COUNT()])])
++- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] range between $2 PRECEDING and $3 FOLLOWING aggs [COUNT()])], window#1=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), SUM($0)])], window#2=[window(partition {1} order by [0 ASC-nulls-first] range between $4 PRECEDING and $3 FOLLOWING aggs [COUNT($0), SUM($0)])], window#3=[window(partition {1} order by [0 ASC-nulls-first, 1 ASC-nulls-first] aggs [RANK()])], window#4=[window(partition {1} order by [1 ASC-nulls-first] rows between $4 PRECEDING and $3 FOLLOWING aggs [COUNT()])])
    +- LogicalProject(a=[$0], c=[$2])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
@@ -135,14 +135,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(EXPR$0=[CASE(>($7, 0), $8, null:INTEGER)], EXPR$1=[$5], EXPR$2=[CAST(/(CASE(>($3, 0), $4, null:INTEGER), $3)):INTEGER], EXPR$3=[$9], EXPR$4=[$6])
-+- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), $SUM0($0)])], window#1=[window(partition {1} order by [1 ASC-nulls-first] aggs [MAX($0), MIN($0)])], window#2=[window(partition {1} order by [2 ASC-nulls-first] aggs [COUNT($0), $SUM0($0), RANK()])])
++- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), SUM($0)])], window#1=[window(partition {1} order by [1 ASC-nulls-first] aggs [MAX($0), MIN($0)])], window#2=[window(partition {1} order by [2 ASC-nulls-first] aggs [COUNT($0), SUM($0), RANK()])])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -161,14 +161,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $2 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $2 NULLS FIRST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST, $1 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $1 NULLS FIRST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(EXPR$0=[CASE(>($8, 0), $9, null:INTEGER)], EXPR$1=[$3], EXPR$2=[CAST(/(CASE(>($5, 0), $6, null:INTEGER), $5)):INTEGER], EXPR$3=[$4], EXPR$4=[$7])
-+- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] aggs [MAX($0)])], window#1=[window(partition {1} order by [0 ASC-nulls-first, 1 ASC-nulls-first] aggs [RANK()])], window#2=[window(partition {1} order by [0 ASC-nulls-first, 2 ASC-nulls-first] aggs [COUNT($0), $SUM0($0)])], window#3=[window(partition {1} order by [1 ASC-nulls-first] aggs [MIN($0)])], window#4=[window(partition {1} order by [2 ASC-nulls-first] aggs [COUNT($0), $SUM0($0)])])
++- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] aggs [MAX($0)])], window#1=[window(partition {1} order by [0 ASC-nulls-first, 1 ASC-nulls-first] aggs [RANK()])], window#2=[window(partition {1} order by [0 ASC-nulls-first, 2 ASC-nulls-first] aggs [COUNT($0), SUM($0)])], window#3=[window(partition {1} order by [1 ASC-nulls-first] aggs [MIN($0)])], window#4=[window(partition {1} order by [2 ASC-nulls-first] aggs [COUNT($0), SUM($0)])])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
@@ -187,14 +187,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$2=[CAST(/(CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST), null:INTEGER), COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST))):INTEGER], EXPR$3=[RANK() OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)], EXPR$4=[MIN($0) OVER (PARTITION BY $1 ORDER BY $0 DESC NULLS LAST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(EXPR$0=[CASE(>($2, 0), $3, null:INTEGER)], EXPR$1=[$4], EXPR$2=[CAST(/(CASE(>($6, 0), $7, null:INTEGER), $6)):INTEGER], EXPR$3=[$5], EXPR$4=[$8])
-+- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), $SUM0($0), MAX($0), RANK()])], window#1=[window(partition {1} order by [0 DESC-nulls-last] aggs [COUNT($0), $SUM0($0), MIN($0)])])
++- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), SUM($0), MAX($0), RANK()])], window#1=[window(partition {1} order by [0 DESC-nulls-last] aggs [COUNT($0), SUM($0), MIN($0)])])
    +- LogicalProject(a=[$0], b=[$1])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
@@ -258,14 +258,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MIN($0) OVER (PARTITION BY $1)], EXPR$2=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)])
+LogicalProject(EXPR$0=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST), null:INTEGER)], EXPR$1=[MIN($0) OVER (PARTITION BY $1)], EXPR$2=[MAX($0) OVER (PARTITION BY $1 ORDER BY $0 NULLS FIRST)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(EXPR$0=[CASE(>($3, 0), $4, null:INTEGER)], EXPR$1=[$2], EXPR$2=[$5])
-+- LogicalWindow(window#0=[window(partition {1} aggs [MIN($0)])], window#1=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), $SUM0($0), MAX($0)])])
++- LogicalWindow(window#0=[window(partition {1} aggs [MIN($0)])], window#1=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), SUM($0), MAX($0)])])
    +- LogicalProject(a=[$0], b=[$1])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml
index 53a2071054002..dc8f600adbb0e 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml
@@ -16,6 +16,35 @@ See the License for the specific language governing permissions and
 limitations under the License.
 -->
 <Root>
+  <TestCase name="testExistsWithCorrelatedOnHaving">
+    <Resource name="sql">
+      <![CDATA[SELECT SUM(a) AS s FROM x GROUP BY b HAVING EXISTS (SELECT * FROM y WHERE y.d = x.b)]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(s=[$1])
++- LogicalFilter(condition=[EXISTS({
+LogicalFilter(condition=[=($1, $cor0.b)])
+  LogicalTableScan(table=[[default_catalog, default_database, y]])
+})], variablesSet=[[$cor0]])
+   +- LogicalAggregate(group=[{0}], s=[SUM($1)])
+      +- LogicalProject(b=[$1], a=[$0])
+         +- LogicalTableScan(table=[[default_catalog, default_database, x]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+LogicalProject(s=[$1])
++- LogicalJoin(condition=[=($2, $1)], joinType=[semi])
+   :- LogicalAggregate(group=[{0}], s=[SUM($1)])
+   :  +- LogicalProject(b=[$1], a=[$0])
+   :     +- LogicalTableScan(table=[[default_catalog, default_database, x]])
+   +- LogicalProject(d=[$1])
+      +- LogicalFilter(condition=[true])
+         +- LogicalTableScan(table=[[default_catalog, default_database, y]])
+]]>
+    </Resource>
+  </TestCase>
   <TestCase name="testExistsWithCorrelatedOnLateralTable1">
     <Resource name="sql">
       <![CDATA[SELECT * FROM l WHERE EXISTS (SELECT * FROM r, LATERAL TABLE(table_func(f)) AS T(f1) WHERE a = d)]]>
@@ -1491,6 +1520,38 @@ LogicalProject(a=[$0], b=[$1], c=[$2])
    +- LogicalProject(d=[$0])
       +- LogicalFilter(condition=[true])
          +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testInWithCorrelatedOnHaving">
+    <Resource name="sql">
+      <![CDATA[SELECT SUM(a) AS s FROM x GROUP BY b HAVING MAX(a) IN (SELECT d FROM y WHERE y.d = x.b)]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(s=[$1])
++- LogicalFilter(condition=[IN($2, {
+LogicalProject(d=[$1])
+  LogicalFilter(condition=[=($1, $cor0.b)])
+    LogicalTableScan(table=[[default_catalog, default_database, y]])
+})], variablesSet=[[$cor0]])
+   +- LogicalAggregate(group=[{0}], s=[SUM($1)], agg#1=[MAX($1)])
+      +- LogicalProject(b=[$1], a=[$0])
+         +- LogicalTableScan(table=[[default_catalog, default_database, x]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+LogicalProject(s=[$1])
++- LogicalProject(b=[$0], s=[$1], $f2=[$2])
+   +- LogicalJoin(condition=[AND(=($3, $4), =($4, $1))], joinType=[semi])
+      :- LogicalProject(b=[$0], s=[$1], $f2=[$2], $f20=[CAST($2):BIGINT])
+      :  +- LogicalAggregate(group=[{0}], s=[SUM($1)], agg#1=[MAX($1)])
+      :     +- LogicalProject(b=[$1], a=[$0])
+      :        +- LogicalTableScan(table=[[default_catalog, default_database, x]])
+      +- LogicalProject(d=[$1])
+         +- LogicalFilter(condition=[true])
+            +- LogicalTableScan(table=[[default_catalog, default_database, y]])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/physical/batch/PushLocalAggIntoTableSourceScanRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/physical/batch/PushLocalAggIntoTableSourceScanRuleTest.xml
index 7852555acf870..229bac52ea0e8 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/physical/batch/PushLocalAggIntoTableSourceScanRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/physical/batch/PushLocalAggIntoTableSourceScanRuleTest.xml
@@ -529,14 +529,14 @@ FROM inventory]]>
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(id=[$0], amount=[$2], EXPR$2=[CASE(>(COUNT($3) OVER (PARTITION BY $1), 0), $SUM0($3) OVER (PARTITION BY $1), null:BIGINT)], name=[$1])
+LogicalProject(id=[$0], amount=[$2], EXPR$2=[CASE(>(COUNT($3) OVER (PARTITION BY $1), 0), SUM($3) OVER (PARTITION BY $1), null:BIGINT)], name=[$1])
 +- LogicalTableScan(table=[[default_catalog, default_database, inventory]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[id, amount, CASE(>(w0$o0, 0), w0$o1, null:BIGINT) AS EXPR$2, name])
-+- OverAggregate(partitionBy=[name], window#0=[COUNT(price) AS w0$o0, $SUM0(price) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], select=[id, name, amount, price, w0$o0, w0$o1])
++- OverAggregate(partitionBy=[name], window#0=[COUNT(price) AS w0$o0, SUM(price) AS w0$o1 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING], select=[id, name, amount, price, w0$o0, w0$o1])
    +- Sort(orderBy=[name ASC])
       +- Exchange(distribution=[hash[name]])
          +- TableSourceScan(table=[[default_catalog, default_database, inventory, project=[id, name, amount, price], metadata=[]]], fields=[id, name, amount, price])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/CalcTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/CalcTest.xml
index 11b409c98fe18..b7b97659a739c 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/CalcTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/CalcTest.xml
@@ -181,13 +181,13 @@ Calc(select=[a, b, c], where=[((a < 10) AND (b > 20))])
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[ARRAY(0.12:DECIMAL(3, 2), 0.5:DECIMAL(3, 2), 0.99:DECIMAL(3, 2))])
+LogicalProject(EXPR$0=[ARRAY(0.12:DECIMAL(3, 2), 0.50:DECIMAL(3, 2), 0.99:DECIMAL(3, 2))])
 +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[ARRAY(0.12, 0.5, 0.99) AS EXPR$0])
+Calc(select=[ARRAY(0.12, 0.50, 0.99) AS EXPR$0])
 +- Values(tuples=[[{ 0 }]])
 ]]>
     </Resource>
@@ -198,13 +198,13 @@ Calc(select=[ARRAY(0.12, 0.5, 0.99) AS EXPR$0])
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(EXPR$0=[MAP(_UTF-16LE'a', 0.12:DECIMAL(3, 2), _UTF-16LE'b', 0.5:DECIMAL(3, 2))])
+LogicalProject(EXPR$0=[MAP(_UTF-16LE'a', 0.12:DECIMAL(3, 2), _UTF-16LE'b', 0.50:DECIMAL(3, 2))])
 +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[MAP('a', 0.12, 'b', 0.5) AS EXPR$0])
+Calc(select=[MAP('a', 0.12, 'b', 0.50) AS EXPR$0])
 +- Values(tuples=[[{ 0 }]])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/DeltaJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/DeltaJoinTest.xml
index 7c04bf6c2aaa6..0995440d9eeb7 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/DeltaJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/DeltaJoinTest.xml
@@ -377,7 +377,7 @@ Sink(table=[default_catalog.default_database.snk], fields=[a0, a1, a2, a3, b0, b
       <![CDATA[
 LogicalSink(table=[default_catalog.default_database.snk], fields=[a0, a1, a2, a3, b0, b2, b1])
 +- LogicalProject(a0=[$0], a1=[$1], a2=[$2], a3=[$3], b0=[$4], b2=[$5], b1=[$6])
-   +- LogicalJoin(condition=[AND(=($1, 1.1), =($2, $5))], joinType=[inner])
+   +- LogicalJoin(condition=[AND(=($1, 1.1E0), =($2, $5))], joinType=[inner])
       :- LogicalTableScan(table=[[default_catalog, default_database, src1]])
       +- LogicalTableScan(table=[[default_catalog, default_database, src2]])
 ]]>
@@ -385,7 +385,7 @@ LogicalSink(table=[default_catalog.default_database.snk], fields=[a0, a1, a2, a3
     <Resource name="optimized rel plan">
       <![CDATA[
 Sink(table=[default_catalog.default_database.snk], fields=[a0, a1, a2, a3, b0, b2, b1], conflictStrategy=[DEDUPLICATE])
-+- Calc(select=[a0, 1.1000000000000000888E0 AS a1, a2, a3, b0, b2, b1])
++- Calc(select=[a0, 1.1E0 AS a1, a2, a3, b0, b2, b1])
    +- Join(joinType=[InnerJoin], where=[=(a2, b2)], select=[a0, a2, a3, b0, b2, b1], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
       :- Exchange(distribution=[hash[a2]])
       :  +- Calc(select=[a0, a2, a3], where=[=(a1, 1.1E0)])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/MatchRecognizeTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/MatchRecognizeTest.xml
index f1c3ad35fb0df..c495a0e085425 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/MatchRecognizeTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/MatchRecognizeTest.xml
@@ -189,7 +189,7 @@ FROM T
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(symbol=[$0], price=[$1], tax=[$2], matchRowtime=[$3], price_sum=[CASE(>(COUNT($1) OVER (PARTITION BY $0 ORDER BY $3 NULLS FIRST), 0), $SUM0($1) OVER (PARTITION BY $0 ORDER BY $3 NULLS FIRST), null:INTEGER)]), rowType=[RecordType(VARCHAR(2147483647) symbol, INTEGER price, INTEGER tax, TIMESTAMP_LTZ(3) *ROWTIME* matchRowtime, INTEGER price_sum)]
+LogicalProject(symbol=[$0], price=[$1], tax=[$2], matchRowtime=[$3], price_sum=[CASE(>(COUNT($1) OVER (PARTITION BY $0 ORDER BY $3 NULLS FIRST), 0), SUM($1) OVER (PARTITION BY $0 ORDER BY $3 NULLS FIRST), null:INTEGER)]), rowType=[RecordType(VARCHAR(2147483647) symbol, INTEGER price, INTEGER tax, TIMESTAMP_LTZ(3) *ROWTIME* matchRowtime, INTEGER price_sum)]
 +- LogicalProject(symbol=[$0], price=[$1], tax=[$2], matchRowtime=[$3]), rowType=[RecordType(VARCHAR(2147483647) symbol, INTEGER price, INTEGER tax, TIMESTAMP_LTZ(3) *ROWTIME* matchRowtime)]
    +- LogicalMatch(partition=[[0]], order=[[1 ASC-nulls-first]], outputFields=[[symbol, price, tax, matchRowtime]], allRows=[false], after=[FLAG(SKIP TO NEXT ROW)], pattern=[_UTF-16LE'A'], isStrictStarts=[false], isStrictEnds=[false], subsets=[[]], patternDefinitions=[[>(PREV(A.$2, 0), 0)]], inputFields=[[symbol, ts_ltz, price, tax]]), rowType=[RecordType(VARCHAR(2147483647) symbol, INTEGER price, INTEGER tax, TIMESTAMP_LTZ(3) *ROWTIME* matchRowtime)]
       +- LogicalWatermarkAssigner(rowtime=[ts_ltz], watermark=[-($1, 1000:INTERVAL SECOND)]), rowType=[RecordType(VARCHAR(2147483647) symbol, TIMESTAMP_LTZ(3) *ROWTIME* ts_ltz, INTEGER price, INTEGER tax)]
@@ -199,7 +199,7 @@ LogicalProject(symbol=[$0], price=[$1], tax=[$2], matchRowtime=[$3], price_sum=[
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[symbol, price, tax, matchRowtime, CASE(>(w0$o0, 0), w0$o1, null:INTEGER) AS price_sum]), rowType=[RecordType(VARCHAR(2147483647) symbol, INTEGER price, INTEGER tax, TIMESTAMP_LTZ(3) *ROWTIME* matchRowtime, INTEGER price_sum)]
-+- OverAggregate(partitionBy=[symbol], orderBy=[matchRowtime ASC], window=[ RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[symbol, price, tax, matchRowtime, COUNT(price) AS w0$o0, $SUM0(price) AS w0$o1]), rowType=[RecordType(VARCHAR(2147483647) symbol, INTEGER price, INTEGER tax, TIMESTAMP_LTZ(3) *ROWTIME* matchRowtime, BIGINT w0$o0, INTEGER w0$o1)]
++- OverAggregate(partitionBy=[symbol], orderBy=[matchRowtime ASC], window=[ RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[symbol, price, tax, matchRowtime, COUNT(price) AS w0$o0, SUM(price) AS w0$o1]), rowType=[RecordType(VARCHAR(2147483647) symbol, INTEGER price, INTEGER tax, TIMESTAMP_LTZ(3) *ROWTIME* matchRowtime, BIGINT w0$o0, INTEGER w0$o1)]
    +- Exchange(distribution=[hash[symbol]]), rowType=[RecordType(VARCHAR(2147483647) symbol, INTEGER price, INTEGER tax, TIMESTAMP_LTZ(3) *ROWTIME* matchRowtime)]
       +- Match(partitionBy=[symbol], orderBy=[ts_ltz ASC], measures=[FINAL(A.price) AS price, FINAL(A.tax) AS tax, FINAL(MATCH_ROWTIME(*.ts_ltz)) AS matchRowtime], rowsPerMatch=[ONE ROW PER MATCH], after=[SKIP TO NEXT ROW], pattern=[_UTF-16LE'A'], define=[{A=>(PREV(A.$2, 0), 0)}]), rowType=[RecordType(VARCHAR(2147483647) symbol, INTEGER price, INTEGER tax, TIMESTAMP_LTZ(3) *ROWTIME* matchRowtime)]
          +- Exchange(distribution=[hash[symbol]]), rowType=[RecordType(VARCHAR(2147483647) symbol, TIMESTAMP_LTZ(3) *ROWTIME* ts_ltz, INTEGER price, INTEGER tax)]
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/UnionTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/UnionTest.xml
index 2969cdc7486ee..0dbdafc413b55 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/UnionTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/UnionTest.xml
@@ -70,7 +70,7 @@ LogicalProject(a=[$0], b=[$1]), rowType=[RecordType(INTEGER a, DECIMAL(20, 1) b)
 +- LogicalUnion(all=[true]), rowType=[RecordType(INTEGER a, DECIMAL(20, 1) b)]
    :- LogicalProject(a=[$0], b=[$1]), rowType=[RecordType(INTEGER a, BIGINT b)]
    :  +- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]]), rowType=[RecordType(INTEGER a, BIGINT b, VARCHAR(2147483647) c)]
-   +- LogicalProject(a=[$0], EXPR$1=[0:DECIMAL(2, 1)]), rowType=[RecordType(INTEGER a, DECIMAL(2, 1) EXPR$1)]
+   +- LogicalProject(a=[$0], EXPR$1=[0.0:DECIMAL(2, 1)]), rowType=[RecordType(INTEGER a, DECIMAL(2, 1) EXPR$1)]
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]]), rowType=[RecordType(INTEGER a, BIGINT b, VARCHAR(2147483647) c)]
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/ValuesTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/ValuesTest.xml
index 098ecd36f3471..42260c1b33fc6 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/ValuesTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/ValuesTest.xml
@@ -100,7 +100,8 @@ LogicalProject(a=[$0], b=[$1], c=[$2])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Values(tuples=[[{ 1, 2, 3 }]])
+Calc(select=[1 AS a, 2 AS b, 3 AS c])
++- Values(tuples=[[{ 1, 2, 3 }]])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/AggregateTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/AggregateTest.xml
index 92fccedf388e4..c2a34a6c49bac 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/AggregateTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/AggregateTest.xml
@@ -68,7 +68,7 @@ FROM T GROUP BY a
     <Resource name="ast">
       <![CDATA[
 LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[SUM($2)], EXPR$3=[SUM($3)], EXPR$4=[SUM($4)], EXPR$5=[SUM($5)], EXPR$6=[SUM($6)], EXPR$7=[SUM($7)]), rowType=[RecordType(INTEGER a, INTEGER EXPR$1, BIGINT EXPR$2, TINYINT EXPR$3, SMALLINT EXPR$4, FLOAT EXPR$5, DECIMAL(38, 0) EXPR$6, DOUBLE EXPR$7)]
-+- LogicalProject(a=[$0], $f1=[1], $f2=[2:BIGINT], $f3=[3:TINYINT], $f4=[4:SMALLINT], $f5=[5:FLOAT], $f6=[6:DECIMAL(10, 0)], $f7=[7:DOUBLE]), rowType=[RecordType(INTEGER a, INTEGER $f1, BIGINT $f2, TINYINT $f3, SMALLINT $f4, FLOAT $f5, DECIMAL(10, 0) $f6, DOUBLE $f7)]
++- LogicalProject(a=[$0], $f1=[1], $f2=[2:BIGINT], $f3=[3:TINYINT], $f4=[4:SMALLINT], $f5=[5.0E0:FLOAT], $f6=[6:DECIMAL(10, 0)], $f7=[7.0E0:DOUBLE]), rowType=[RecordType(INTEGER a, INTEGER $f1, BIGINT $f2, TINYINT $f3, SMALLINT $f4, FLOAT $f5, DECIMAL(10, 0) $f6, DOUBLE $f7)]
    +- LogicalTableScan(table=[[default_catalog, default_database, T]]), rowType=[RecordType(INTEGER a, BIGINT b, VARCHAR(2147483647) c, BOOLEAN d)]
 ]]>
     </Resource>
@@ -76,7 +76,7 @@ LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[SUM($2)], EXPR$3=[SUM($3
       <![CDATA[
 GroupAggregate(groupBy=[a], select=[a, SUM($f1) AS EXPR$1, SUM($f2) AS EXPR$2, SUM($f3) AS EXPR$3, SUM($f4) AS EXPR$4, SUM($f5) AS EXPR$5, SUM($f6) AS EXPR$6, SUM($f7) AS EXPR$7]), rowType=[RecordType(INTEGER a, INTEGER EXPR$1, BIGINT EXPR$2, TINYINT EXPR$3, SMALLINT EXPR$4, FLOAT EXPR$5, DECIMAL(38, 0) EXPR$6, DOUBLE EXPR$7)]
 +- Exchange(distribution=[hash[a]]), rowType=[RecordType(INTEGER a, INTEGER $f1, BIGINT $f2, TINYINT $f3, SMALLINT $f4, FLOAT $f5, DECIMAL(10, 0) $f6, DOUBLE $f7)]
-   +- Calc(select=[a, 1 AS $f1, 2 AS $f2, 3 AS $f3, 4 AS $f4, 5 AS $f5, 6 AS $f6, 7 AS $f7]), rowType=[RecordType(INTEGER a, INTEGER $f1, BIGINT $f2, TINYINT $f3, SMALLINT $f4, FLOAT $f5, DECIMAL(10, 0) $f6, DOUBLE $f7)]
+   +- Calc(select=[a, 1 AS $f1, 2 AS $f2, 3 AS $f3, 4 AS $f4, 5.0E0 AS $f5, 6 AS $f6, 7.0E0 AS $f7]), rowType=[RecordType(INTEGER a, INTEGER $f1, BIGINT $f2, TINYINT $f3, SMALLINT $f4, FLOAT $f5, DECIMAL(10, 0) $f6, DOUBLE $f7)]
       +- TableSourceScan(table=[[default_catalog, default_database, T]], fields=[a, b, c, d]), rowType=[RecordType(INTEGER a, BIGINT b, VARCHAR(2147483647) c, BOOLEAN d)]
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/OverAggregateTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/OverAggregateTest.xml
index dc0185da0ec8d..fdd3264866764 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/OverAggregateTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/OverAggregateTest.xml
@@ -111,14 +111,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(a=[$0], avgA=[/(CASE(>(COUNT($2) OVER (PARTITION BY $0 ORDER BY $3 NULLS FIRST RANGE 7200000:INTERVAL HOUR PRECEDING), 0), $SUM0($2) OVER (PARTITION BY $0 ORDER BY $3 NULLS FIRST RANGE 7200000:INTERVAL HOUR PRECEDING), null:BIGINT), COUNT($2) OVER (PARTITION BY $0 ORDER BY $3 NULLS FIRST RANGE 7200000:INTERVAL HOUR PRECEDING))])
+LogicalProject(a=[$0], avgA=[/(CASE(>(COUNT($2) OVER (PARTITION BY $0 ORDER BY $3 NULLS FIRST RANGE 7200000:INTERVAL HOUR PRECEDING), 0), SUM($2) OVER (PARTITION BY $0 ORDER BY $3 NULLS FIRST RANGE 7200000:INTERVAL HOUR PRECEDING), null:BIGINT), COUNT($2) OVER (PARTITION BY $0 ORDER BY $3 NULLS FIRST RANGE 7200000:INTERVAL HOUR PRECEDING))])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, (CASE((w0$o0 > 0), w0$o1, null:BIGINT) / w0$o0) AS avgA])
-+- OverAggregate(partitionBy=[a], orderBy=[proctime ASC], window=[ RANGE BETWEEN 7200000 PRECEDING AND CURRENT ROW], select=[a, c, proctime, COUNT(c) AS w0$o0, $SUM0(c) AS w0$o1])
++- OverAggregate(partitionBy=[a], orderBy=[proctime ASC], window=[ RANGE BETWEEN 7200000 PRECEDING AND CURRENT ROW], select=[a, c, proctime, COUNT(c) AS w0$o0, SUM(c) AS w0$o1])
    +- Exchange(distribution=[hash[a]])
       +- Calc(select=[a, c, proctime])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
@@ -138,14 +138,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING)], sum1=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), null:INTEGER)])
+LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING)], sum1=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), null:INTEGER)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, w0$o0 AS cnt1, CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS sum1])
-+- OverAggregate(partitionBy=[c], orderBy=[proctime ASC], window=[ ROWS BETWEEN 2 PRECEDING AND CURRENT ROW], select=[a, c, proctime, COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1])
++- OverAggregate(partitionBy=[c], orderBy=[proctime ASC], window=[ ROWS BETWEEN 2 PRECEDING AND CURRENT ROW], select=[a, c, proctime, COUNT(a) AS w0$o0, SUM(a) AS w0$o1])
    +- Exchange(distribution=[hash[c]])
       +- Calc(select=[a, c, proctime])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
@@ -158,14 +158,14 @@ Calc(select=[c, w0$o0 AS cnt1, CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS sum1])
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(a=[$0], EXPR$1=[CASE(>(COUNT($2) OVER (PARTITION BY $0 ORDER BY PROCTIME() NULLS FIRST ROWS 4 PRECEDING), 0), $SUM0($2) OVER (PARTITION BY $0 ORDER BY PROCTIME() NULLS FIRST ROWS 4 PRECEDING), null:BIGINT)], EXPR$2=[MIN($2) OVER (PARTITION BY $0 ORDER BY PROCTIME() NULLS FIRST ROWS 4 PRECEDING)])
+LogicalProject(a=[$0], EXPR$1=[CASE(>(COUNT($2) OVER (PARTITION BY $0 ORDER BY PROCTIME() NULLS FIRST ROWS 4 PRECEDING), 0), SUM($2) OVER (PARTITION BY $0 ORDER BY PROCTIME() NULLS FIRST ROWS 4 PRECEDING), null:BIGINT)], EXPR$2=[MIN($2) OVER (PARTITION BY $0 ORDER BY PROCTIME() NULLS FIRST ROWS 4 PRECEDING)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[a, CASE((w0$o0 > 0), w0$o1, null:BIGINT) AS EXPR$1, w0$o2 AS EXPR$2])
-+- OverAggregate(partitionBy=[a], orderBy=[$2 ASC], window=[ ROWS BETWEEN 4 PRECEDING AND CURRENT ROW], select=[a, c, $2, COUNT(c) AS w0$o0, $SUM0(c) AS w0$o1, MIN(c) AS w0$o2])
++- OverAggregate(partitionBy=[a], orderBy=[$2 ASC], window=[ ROWS BETWEEN 4 PRECEDING AND CURRENT ROW], select=[a, c, $2, COUNT(c) AS w0$o0, SUM(c) AS w0$o1, MIN(c) AS w0$o2])
    +- Exchange(distribution=[hash[a]])
       +- Calc(select=[a, c, PROCTIME() AS $2])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
@@ -183,14 +183,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (ORDER BY $3 NULLS FIRST)], cnt2=[CASE(>(COUNT($0) OVER (ORDER BY $3 NULLS FIRST), 0), $SUM0($0) OVER (ORDER BY $3 NULLS FIRST), null:INTEGER)])
+LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (ORDER BY $3 NULLS FIRST)], cnt2=[CASE(>(COUNT($0) OVER (ORDER BY $3 NULLS FIRST), 0), SUM($0) OVER (ORDER BY $3 NULLS FIRST), null:INTEGER)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, w0$o0 AS cnt1, CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS cnt2])
-+- OverAggregate(orderBy=[proctime ASC], window=[ RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, proctime, COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1])
++- OverAggregate(orderBy=[proctime ASC], window=[ RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, proctime, COUNT(a) AS w0$o0, SUM(a) AS w0$o1])
    +- Exchange(distribution=[single])
       +- Calc(select=[a, c, proctime])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
@@ -231,14 +231,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST)], cnt2=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST), null:INTEGER)])
+LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST)], cnt2=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST), null:INTEGER)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, w0$o0 AS cnt1, CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS cnt2])
-+- OverAggregate(partitionBy=[c], orderBy=[proctime ASC], window=[ RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, proctime, COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1])
++- OverAggregate(partitionBy=[c], orderBy=[proctime ASC], window=[ RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, proctime, COUNT(a) AS w0$o0, SUM(a) AS w0$o1])
    +- Exchange(distribution=[hash[c]])
       +- Calc(select=[a, c, proctime])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
@@ -282,14 +282,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(c=[$2], cnt1=[COUNT(DISTINCT $0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING)], sum1=[CASE(>(COUNT(DISTINCT $0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), 0), $SUM0(DISTINCT $0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), null:INTEGER)])
+LogicalProject(c=[$2], cnt1=[COUNT(DISTINCT $0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING)], sum1=[CASE(>(COUNT(DISTINCT $0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), 0), SUM(DISTINCT $0) OVER (PARTITION BY $2 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), null:INTEGER)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, w0$o0 AS cnt1, CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS sum1])
-+- OverAggregate(partitionBy=[c], orderBy=[proctime ASC], window=[ ROWS BETWEEN 2 PRECEDING AND CURRENT ROW], select=[a, c, proctime, COUNT(DISTINCT a) AS w0$o0, $SUM0(DISTINCT a) AS w0$o1])
++- OverAggregate(partitionBy=[c], orderBy=[proctime ASC], window=[ ROWS BETWEEN 2 PRECEDING AND CURRENT ROW], select=[a, c, proctime, COUNT(DISTINCT a) AS w0$o0, SUM(DISTINCT a) AS w0$o1])
    +- Exchange(distribution=[hash[c]])
       +- Calc(select=[a, c, proctime])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
@@ -313,14 +313,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(b=[$1], cnt1=[COUNT($0) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING)], sum1=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), 0), $SUM0($0) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), null:INTEGER)], cnt2=[COUNT(DISTINCT $0) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING)], sum2=[CASE(>(COUNT(DISTINCT $2) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), 0), $SUM0(DISTINCT $2) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), null:BIGINT)])
+LogicalProject(b=[$1], cnt1=[COUNT($0) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING)], sum1=[CASE(>(COUNT($0) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), 0), SUM($0) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), null:INTEGER)], cnt2=[COUNT(DISTINCT $0) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING)], sum2=[CASE(>(COUNT(DISTINCT $2) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), 0), SUM(DISTINCT $2) OVER (PARTITION BY $1 ORDER BY $3 NULLS FIRST ROWS 2 PRECEDING), null:BIGINT)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[b, w0$o0 AS cnt1, CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS sum1, w0$o2 AS cnt2, CASE((w0$o3 > 0), w0$o4, null:BIGINT) AS sum2])
-+- OverAggregate(partitionBy=[b], orderBy=[proctime ASC], window=[ ROWS BETWEEN 2 PRECEDING AND CURRENT ROW], select=[a, b, c, proctime, COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1, COUNT(DISTINCT a) AS w0$o2, COUNT(DISTINCT c) AS w0$o3, $SUM0(DISTINCT c) AS w0$o4])
++- OverAggregate(partitionBy=[b], orderBy=[proctime ASC], window=[ ROWS BETWEEN 2 PRECEDING AND CURRENT ROW], select=[a, b, c, proctime, COUNT(a) AS w0$o0, SUM(a) AS w0$o1, COUNT(DISTINCT a) AS w0$o2, COUNT(DISTINCT c) AS w0$o3, SUM(DISTINCT c) AS w0$o4])
    +- Exchange(distribution=[hash[b]])
       +- Calc(select=[a, b, c, proctime])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
@@ -437,14 +437,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (ORDER BY $4 NULLS FIRST)], cnt2=[CASE(>(COUNT($0) OVER (ORDER BY $4 NULLS FIRST), 0), $SUM0($0) OVER (ORDER BY $4 NULLS FIRST), null:INTEGER)])
+LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (ORDER BY $4 NULLS FIRST)], cnt2=[CASE(>(COUNT($0) OVER (ORDER BY $4 NULLS FIRST), 0), SUM($0) OVER (ORDER BY $4 NULLS FIRST), null:INTEGER)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, w0$o0 AS cnt1, CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS cnt2])
-+- OverAggregate(orderBy=[rowtime ASC], window=[ RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, rowtime, COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1])
++- OverAggregate(orderBy=[rowtime ASC], window=[ RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, rowtime, COUNT(a) AS w0$o0, SUM(a) AS w0$o1])
    +- Exchange(distribution=[single])
       +- Calc(select=[a, c, rowtime])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
@@ -462,14 +462,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING)], cnt2=[CASE(>(COUNT($0) OVER (ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING), 0), $SUM0($0) OVER (ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING), null:INTEGER)])
+LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING)], cnt2=[CASE(>(COUNT($0) OVER (ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING), 0), SUM($0) OVER (ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING), null:INTEGER)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, w0$o0 AS cnt1, CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS cnt2])
-+- OverAggregate(orderBy=[rowtime ASC], window=[ ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, rowtime, COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1])
++- OverAggregate(orderBy=[rowtime ASC], window=[ ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, rowtime, COUNT(a) AS w0$o0, SUM(a) AS w0$o1])
    +- Exchange(distribution=[single])
       +- Calc(select=[a, c, rowtime])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
@@ -487,14 +487,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST)], cnt2=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST), null:INTEGER)])
+LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST)], cnt2=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST), null:INTEGER)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, w0$o0 AS cnt1, CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS cnt2])
-+- OverAggregate(partitionBy=[c], orderBy=[rowtime ASC], window=[ RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, rowtime, COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1])
++- OverAggregate(partitionBy=[c], orderBy=[rowtime ASC], window=[ RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, rowtime, COUNT(a) AS w0$o0, SUM(a) AS w0$o1])
    +- Exchange(distribution=[hash[c]])
       +- Calc(select=[a, c, rowtime])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
@@ -512,14 +512,14 @@ FROM MyTable
     </Resource>
     <Resource name="ast">
       <![CDATA[
-LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING)], cnt2=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING), 0), $SUM0($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING), null:INTEGER)])
+LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING)], cnt2=[CASE(>(COUNT($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING), 0), SUM($0) OVER (PARTITION BY $2 ORDER BY $4 NULLS FIRST ROWS UNBOUNDED PRECEDING), null:INTEGER)])
 +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, w0$o0 AS cnt1, CASE((w0$o0 > 0), w0$o1, null:INTEGER) AS cnt2])
-+- OverAggregate(partitionBy=[c], orderBy=[rowtime ASC], window=[ ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, rowtime, COUNT(a) AS w0$o0, $SUM0(a) AS w0$o1])
++- OverAggregate(partitionBy=[c], orderBy=[rowtime ASC], window=[ ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], select=[a, c, rowtime, COUNT(a) AS w0$o0, SUM(a) AS w0$o1])
    +- Exchange(distribution=[hash[c]])
       +- Calc(select=[a, c, rowtime])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
@@ -728,7 +728,7 @@ LogicalProject(c=[$2], cnt1=[COUNT($0) OVER (PARTITION BY $1 ORDER BY $3 NULLS F
     <Resource name="optimized exec plan">
       <![CDATA[
 Calc(select=[c, w0$o0 AS $1])
-+- OverAggregate(partitionBy=[b], orderBy=[proctime ASC], window=[ ROWS BETWEEN 16 PRECEDING AND CURRENT ROW], select=[a, b, c, proctime, COUNT(a) AS w0$o0])
++- OverAggregate(partitionBy=[b], orderBy=[proctime ASC], window=[ ROWS BETWEEN 16.0 PRECEDING AND CURRENT ROW], select=[a, b, c, proctime, COUNT(a) AS w0$o0])
    +- Exchange(distribution=[hash[b]])
       +- Calc(select=[a, b, c, proctime])
          +- DataStreamScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c, proctime, rowtime])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/table/ValuesTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/table/ValuesTest.xml
index 3ca767eb55948..5a2078588d0de 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/table/ValuesTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/table/ValuesTest.xml
@@ -33,11 +33,11 @@ Values(tuples=[[{ 1, 2, _UTF-16LE'JKL' }, { 2, 3, _UTF-16LE'GHI' }, { 3, 4, _UTF
       <![CDATA[
 LogicalUnion(all=[true])
 :- LogicalValues(tuples=[[{ null }]])
-:- LogicalProject(f0=[CAST(1:FLOAT):FLOAT])
+:- LogicalProject(f0=[CAST(1.0E0:FLOAT):FLOAT])
 :  +- LogicalValues(tuples=[[{ 0 }]])
 :- LogicalProject(f0=[CAST(3.1E0:FLOAT):FLOAT])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-+- LogicalProject(f0=[CAST(99:FLOAT):FLOAT])
++- LogicalProject(f0=[CAST(99.0E0:FLOAT):FLOAT])
    +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
@@ -45,11 +45,11 @@ LogicalUnion(all=[true])
       <![CDATA[
 Union(all=[true], union=[f0])
 :- Values(tuples=[[{ null }]])
-:- Calc(select=[CAST(1 AS FLOAT) AS f0])
+:- Calc(select=[CAST(1.0E0 AS FLOAT) AS f0])
 :  +- Values(tuples=[[{ 0 }]])(reuse_id=[1])
 :- Calc(select=[CAST(3.1E0 AS FLOAT) AS f0])
 :  +- Reused(reference_id=[1])
-+- Calc(select=[CAST(99 AS FLOAT) AS f0])
++- Calc(select=[CAST(99.0E0 AS FLOAT) AS f0])
    +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -58,30 +58,30 @@ Union(all=[true], union=[f0])
     <Resource name="ast">
       <![CDATA[
 LogicalUnion(all=[true])
-:- LogicalProject(f0=[1:DOUBLE], f1=[_UTF-16LE'ABC':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[null:INTEGER])
+:- LogicalProject(f0=[1.0E0:DOUBLE], f1=[_UTF-16LE'ABC':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[null:INTEGER])
 :  +- LogicalValues(tuples=[[{ 0 }]])
 :- LogicalProject(f0=[3.141592653589793E0:DOUBLE], f1=[_UTF-16LE'ABC':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[CAST(1):INTEGER])
 :  +- LogicalValues(tuples=[[{ 0 }]])
 :- LogicalProject(f0=[3.1E0:DOUBLE], f1=[_UTF-16LE'DEF':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[CAST(2):INTEGER])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-:- LogicalProject(f0=[99:DOUBLE], f1=[_UTF-16LE'DEFG':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[null:INTEGER])
+:- LogicalProject(f0=[99.0E0:DOUBLE], f1=[_UTF-16LE'DEFG':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[null:INTEGER])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-+- LogicalProject(f0=[0E-1:DOUBLE], f1=[_UTF-16LE'D':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[CAST(4):INTEGER])
++- LogicalProject(f0=[0.0E0:DOUBLE], f1=[_UTF-16LE'D':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[CAST(4):INTEGER])
    +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Union(all=[true], union=[f0, f1, f2])
-:- Calc(select=[1 AS f0, 'ABC' AS f1, null:INTEGER AS f2])
+:- Calc(select=[1.0E0 AS f0, 'ABC' AS f1, null:INTEGER AS f2])
 :  +- Values(tuples=[[{ 0 }]])(reuse_id=[1])
 :- Calc(select=[3.141592653589793E0 AS f0, 'ABC' AS f1, CAST(1 AS INTEGER) AS f2])
 :  +- Reused(reference_id=[1])
 :- Calc(select=[3.1E0 AS f0, 'DEF' AS f1, CAST(2 AS INTEGER) AS f2])
 :  +- Reused(reference_id=[1])
-:- Calc(select=[99 AS f0, 'DEFG' AS f1, null:INTEGER AS f2])
+:- Calc(select=[99.0E0 AS f0, 'DEFG' AS f1, null:INTEGER AS f2])
 :  +- Reused(reference_id=[1])
-+- Calc(select=[0E-1 AS f0, 'D' AS f1, CAST(4 AS INTEGER) AS f2])
++- Calc(select=[0.0E0 AS f0, 'D' AS f1, CAST(4 AS INTEGER) AS f2])
    +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -90,7 +90,7 @@ Union(all=[true], union=[f0, f1, f2])
     <Resource name="ast">
       <![CDATA[
 LogicalUnion(all=[true])
-:- LogicalProject(f0=[1:DOUBLE], f1=[ROW(_UTF-16LE'A':VARCHAR(3) CHARACTER SET "UTF-16LE", 2:DOUBLE)], f2=[ARRAY(1:BIGINT)])
+:- LogicalProject(f0=[1.0E0:DOUBLE], f1=[ROW(_UTF-16LE'A':VARCHAR(3) CHARACTER SET "UTF-16LE", 2.0E0:DOUBLE)], f2=[ARRAY(1:BIGINT)])
 :  +- LogicalValues(tuples=[[{ 0 }]])
 +- LogicalProject(f0=[3.141592653589793E0:DOUBLE], f1=[ROW(_UTF-16LE'ABC':VARCHAR(3) CHARACTER SET "UTF-16LE", 3.0E0:DOUBLE)], f2=[ARRAY(3:BIGINT)])
    +- LogicalValues(tuples=[[{ 0 }]])
@@ -99,7 +99,7 @@ LogicalUnion(all=[true])
     <Resource name="optimized exec plan">
       <![CDATA[
 Union(all=[true], union=[f0, f1, f2])
-:- Calc(select=[1 AS f0, ROW('A', 2) AS f1, ARRAY(1) AS f2])
+:- Calc(select=[1.0E0 AS f0, ROW('A', 2.0E0) AS f1, ARRAY(1) AS f2])
 :  +- Values(tuples=[[{ 0 }]])(reuse_id=[1])
 +- Calc(select=[3.141592653589793E0 AS f0, ROW('ABC', 3.0E0) AS f1, ARRAY(3) AS f2])
    +- Reused(reference_id=[1])
@@ -116,28 +116,28 @@ LogicalUnion(all=[true])
 :  +- LogicalValues(tuples=[[{ 0 }]])
 :- LogicalProject(f0=[PI], f1=[_UTF-16LE'ABC':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[MAP(_UTF-16LE'abc':VARCHAR(4) CHARACTER SET "UTF-16LE", 3.0E0:DOUBLE)])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-:- LogicalProject(f0=[3.1E0:DOUBLE], f1=[_UTF-16LE'DEF':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[MAP(_UTF-16LE'abcd':VARCHAR(4) CHARACTER SET "UTF-16LE", 3:DOUBLE)])
+:- LogicalProject(f0=[3.1E0:DOUBLE], f1=[_UTF-16LE'DEF':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[MAP(_UTF-16LE'abcd':VARCHAR(4) CHARACTER SET "UTF-16LE", 3.0E0:DOUBLE)])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-:- LogicalProject(f0=[99:DOUBLE], f1=[_UTF-16LE'DEFG':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[MAP(_UTF-16LE'a':VARCHAR(4) CHARACTER SET "UTF-16LE", 1:DOUBLE)])
+:- LogicalProject(f0=[99.0E0:DOUBLE], f1=[_UTF-16LE'DEFG':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[MAP(_UTF-16LE'a':VARCHAR(4) CHARACTER SET "UTF-16LE", 1.0E0:DOUBLE)])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-+- LogicalProject(f0=[0E-1:DOUBLE], f1=[_UTF-16LE'D':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[null:(VARCHAR(4) CHARACTER SET "UTF-16LE", DOUBLE) MAP])
++- LogicalProject(f0=[0.0E0:DOUBLE], f1=[_UTF-16LE'D':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[null:(VARCHAR(4) CHARACTER SET "UTF-16LE", DOUBLE) MAP])
    +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Union(all=[true], union=[f0, f1, f2])
-:- Calc(select=[4E0 AS f0, 'ABC' AS f1, MAP('a', 3.0E0) AS f2])
+:- Calc(select=[4.0E0 AS f0, 'ABC' AS f1, MAP('a', 3.0E0) AS f2])
 :  +- Values(tuples=[[{ 0 }]])(reuse_id=[1])
-:- Calc(select=[3E0 AS f0, 'ABC' AS f1, MAP('a', CAST((ABS(-5) + -5) AS DOUBLE)) AS f2])
+:- Calc(select=[3.0E0 AS f0, 'ABC' AS f1, MAP('a', CAST((ABS(-5) + -5) AS DOUBLE)) AS f2])
 :  +- Reused(reference_id=[1])
-:- Calc(select=[3.1415926535897931159E0 AS f0, 'ABC' AS f1, MAP('abc', 3.0E0) AS f2])
+:- Calc(select=[3.141592653589793E0 AS f0, 'ABC' AS f1, MAP('abc', 3.0E0) AS f2])
 :  +- Reused(reference_id=[1])
-:- Calc(select=[3.1E0 AS f0, 'DEF' AS f1, MAP('abcd', 3) AS f2])
+:- Calc(select=[3.1E0 AS f0, 'DEF' AS f1, MAP('abcd', 3.0E0) AS f2])
 :  +- Reused(reference_id=[1])
-:- Calc(select=[99 AS f0, 'DEFG' AS f1, MAP('a', 1) AS f2])
+:- Calc(select=[99.0E0 AS f0, 'DEFG' AS f1, MAP('a', 1.0E0) AS f2])
 :  +- Reused(reference_id=[1])
-+- Calc(select=[0E-1 AS f0, 'D' AS f1, null:(VARCHAR(4), DOUBLE) MAP AS f2])
++- Calc(select=[0.0E0 AS f0, 'D' AS f1, null:(VARCHAR(4), DOUBLE) MAP AS f2])
    +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -146,30 +146,30 @@ Union(all=[true], union=[f0, f1, f2])
     <Resource name="ast">
       <![CDATA[
 LogicalUnion(all=[true])
-:- LogicalProject(f0=[1:DOUBLE], f1=[_UTF-16LE'ABC':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[null:INTEGER])
+:- LogicalProject(f0=[1.0E0:DOUBLE], f1=[_UTF-16LE'ABC':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[null:INTEGER])
 :  +- LogicalValues(tuples=[[{ 0 }]])
 :- LogicalProject(f0=[3.141592653589793E0:DOUBLE], f1=[_UTF-16LE'ABC':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[CAST(1):INTEGER])
 :  +- LogicalValues(tuples=[[{ 0 }]])
 :- LogicalProject(f0=[3.1E0:DOUBLE], f1=[_UTF-16LE'DEF':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[CAST(2):INTEGER])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-:- LogicalProject(f0=[99:DOUBLE], f1=[_UTF-16LE'DEFG':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[CAST(3):INTEGER])
+:- LogicalProject(f0=[99.0E0:DOUBLE], f1=[_UTF-16LE'DEFG':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[CAST(3):INTEGER])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-+- LogicalProject(f0=[0E-1:DOUBLE], f1=[_UTF-16LE'D':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[CAST(4):INTEGER])
++- LogicalProject(f0=[0.0E0:DOUBLE], f1=[_UTF-16LE'D':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[CAST(4):INTEGER])
    +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Union(all=[true], union=[f0, f1, f2])
-:- Calc(select=[1 AS f0, 'ABC' AS f1, null:INTEGER AS f2])
+:- Calc(select=[1.0E0 AS f0, 'ABC' AS f1, null:INTEGER AS f2])
 :  +- Values(tuples=[[{ 0 }]])(reuse_id=[1])
 :- Calc(select=[3.141592653589793E0 AS f0, 'ABC' AS f1, CAST(1 AS INTEGER) AS f2])
 :  +- Reused(reference_id=[1])
 :- Calc(select=[3.1E0 AS f0, 'DEF' AS f1, CAST(2 AS INTEGER) AS f2])
 :  +- Reused(reference_id=[1])
-:- Calc(select=[99 AS f0, 'DEFG' AS f1, CAST(3 AS INTEGER) AS f2])
+:- Calc(select=[99.0E0 AS f0, 'DEFG' AS f1, CAST(3 AS INTEGER) AS f2])
 :  +- Reused(reference_id=[1])
-+- Calc(select=[0E-1 AS f0, 'D' AS f1, CAST(4 AS INTEGER) AS f2])
++- Calc(select=[0.0E0 AS f0, 'D' AS f1, CAST(4 AS INTEGER) AS f2])
    +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -178,30 +178,30 @@ Union(all=[true], union=[f0, f1, f2])
     <Resource name="ast">
       <![CDATA[
 LogicalUnion(all=[true])
-:- LogicalProject(a=[1:DECIMAL(10, 2)], b=[_UTF-16LE'ABC '])
+:- LogicalProject(a=[1.00:DECIMAL(10, 2)], b=[_UTF-16LE'ABC '])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-:- LogicalProject(a=[3.141592653589793E0:DECIMAL(10, 2)], b=[_UTF-16LE'ABC '])
+:- LogicalProject(a=[3.14:DECIMAL(10, 2)], b=[_UTF-16LE'ABC '])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-:- LogicalProject(a=[3.1E0:DECIMAL(10, 2)], b=[_UTF-16LE'DEF '])
+:- LogicalProject(a=[3.10:DECIMAL(10, 2)], b=[_UTF-16LE'DEF '])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-:- LogicalProject(a=[99:DECIMAL(10, 2)], b=[_UTF-16LE'DEFG'])
+:- LogicalProject(a=[99.00:DECIMAL(10, 2)], b=[_UTF-16LE'DEFG'])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-+- LogicalProject(a=[0E-1:DECIMAL(10, 2)], b=[_UTF-16LE'D   '])
++- LogicalProject(a=[0.00:DECIMAL(10, 2)], b=[_UTF-16LE'D   '])
    +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Union(all=[true], union=[a, b])
-:- Calc(select=[1 AS a, 'ABC ' AS b])
+:- Calc(select=[1.00 AS a, 'ABC ' AS b])
 :  +- Values(tuples=[[{ 0 }]])(reuse_id=[1])
-:- Calc(select=[3.141592653589793E0 AS a, 'ABC ' AS b])
+:- Calc(select=[3.14 AS a, 'ABC ' AS b])
 :  +- Reused(reference_id=[1])
-:- Calc(select=[3.1E0 AS a, 'DEF ' AS b])
+:- Calc(select=[3.10 AS a, 'DEF ' AS b])
 :  +- Reused(reference_id=[1])
-:- Calc(select=[99 AS a, 'DEFG' AS b])
+:- Calc(select=[99.00 AS a, 'DEFG' AS b])
 :  +- Reused(reference_id=[1])
-+- Calc(select=[0E-1 AS a, 'D   ' AS b])
++- Calc(select=[0.00 AS a, 'D   ' AS b])
    +- Reused(reference_id=[1])
 ]]>
     </Resource>
@@ -244,18 +244,18 @@ Union(all=[true], union=[a, b])
     <Resource name="ast">
       <![CDATA[
 LogicalUnion(all=[true])
-:- LogicalProject(number=[CAST(1:DOUBLE):DOUBLE], row=[ROW(_UTF-16LE'A    ', 2:DECIMAL(10, 2), ROW(00:00:00:TIME(3)))], array=[ARRAY(1:BIGINT)])
+:- LogicalProject(number=[CAST(1.0E0:DOUBLE):DOUBLE], row=[ROW(_UTF-16LE'A    ', 2.00:DECIMAL(10, 2), ROW(00:00:00:TIME(3)))], array=[ARRAY(1:BIGINT)])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-+- LogicalProject(number=[CAST(3.141592653589793E0:DOUBLE):DOUBLE], row=[ROW(_UTF-16LE'ABC  ', 3.0E0:DECIMAL(10, 2), ROW(00:00:00.1:TIME(3)))], array=[ARRAY(3:BIGINT)])
++- LogicalProject(number=[CAST(3.141592653589793E0:DOUBLE):DOUBLE], row=[ROW(_UTF-16LE'ABC  ', 3.00:DECIMAL(10, 2), ROW(00:00:00.1:TIME(3)))], array=[ARRAY(3:BIGINT)])
    +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
 Union(all=[true], union=[number, row, array])
-:- Calc(select=[CAST(1 AS DOUBLE) AS number, ROW('A    ', 2, ROW(00:00:00)) AS row, ARRAY(1) AS array])
+:- Calc(select=[CAST(1.0E0 AS DOUBLE) AS number, ROW('A    ', 2.00, ROW(00:00:00)) AS row, ARRAY(1) AS array])
 :  +- Values(tuples=[[{ 0 }]])(reuse_id=[1])
-+- Calc(select=[CAST(3.141592653589793E0 AS DOUBLE) AS number, ROW('ABC  ', 3.0E0, ROW(00:00:00.1)) AS row, ARRAY(3) AS array])
++- Calc(select=[CAST(3.141592653589793E0 AS DOUBLE) AS number, ROW('ABC  ', 3.00, ROW(00:00:00.1)) AS row, ARRAY(3) AS array])
    +- Reused(reference_id=[1])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnIntervalTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnIntervalTest.scala
index 232213f48046e..aab16f95d4c9f 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnIntervalTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnIntervalTest.scala
@@ -139,7 +139,7 @@ class FlinkRelMdColumnIntervalTest extends FlinkRelMdHandlerTestBase {
     // id <= 20
     val expr1 = relBuilder.call(LESS_THAN_OR_EQUAL, relBuilder.field(0), relBuilder.literal(20))
     // id > 10.0 (note: the types of id and literal are different)
-    val expr2 = relBuilder.call(GREATER_THAN, relBuilder.field(0), relBuilder.literal(10.0))
+    val expr2 = relBuilder.call(GREATER_THAN, relBuilder.field(0), relBuilder.literal(bd(10.0)))
     // DIV(id, 2) > 3
     val expr3 = relBuilder.call(
       GREATER_THAN,
@@ -165,13 +165,13 @@ class FlinkRelMdColumnIntervalTest extends FlinkRelMdHandlerTestBase {
     // id <= 20 AND id > 10 AND DIV(id, 2) > 3
     val filter2 = relBuilder.push(ts).filter(expr1, expr2, expr3).build
     assertEquals(
-      ValueInterval(bd(10.0), bd(20), includeLower = false),
+      ValueInterval(bd(10.0), bd(20.0), includeLower = false),
       mq.getColumnInterval(filter2, 0))
 
     // id <= 20 AND id > 10 AND score < 4.1
     val filter3 = relBuilder.push(ts).filter(expr1, expr2, expr4).build
     assertEquals(
-      ValueInterval(bd(10.0), bd(20), includeLower = false),
+      ValueInterval(bd(10.0), bd(20.0), includeLower = false),
       mq.getColumnInterval(filter3, 0))
 
     // score > 6.0 OR score <= 4.0
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
index eaca9fa23c901..d8815d3aa6bf7 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
@@ -2435,6 +2435,7 @@ class FlinkRelMdHandlerTestBase {
       true,
       RexWindowBounds.create(SqlWindow.createUnboundedPreceding(new SqlParserPos(0, 0)), null),
       RexWindowBounds.create(SqlWindow.createCurrentRow(new SqlParserPos(0, 0)), null),
+      null,
       RelCollations.of(
         new RelFieldCollation(
           1,
@@ -2568,6 +2569,7 @@ class FlinkRelMdHandlerTestBase {
         true,
         RexWindowBounds.create(SqlWindow.createUnboundedPreceding(new SqlParserPos(0, 0)), null),
         RexWindowBounds.create(SqlWindow.createCurrentRow(new SqlParserPos(0, 0)), null),
+        null,
         RelCollations.of(
           new RelFieldCollation(
             1,
@@ -2589,6 +2591,7 @@ class FlinkRelMdHandlerTestBase {
         false,
         RexWindowBounds.create(SqlWindow.createUnboundedPreceding(new SqlParserPos(4, 15)), null),
         RexWindowBounds.create(SqlWindow.createCurrentRow(new SqlParserPos(0, 0)), null),
+        null,
         RelCollations.of(
           new RelFieldCollation(
             2,
@@ -2634,6 +2637,7 @@ class FlinkRelMdHandlerTestBase {
         false,
         RexWindowBounds.create(SqlWindow.createUnboundedPreceding(new SqlParserPos(7, 19)), null),
         RexWindowBounds.create(SqlWindow.createUnboundedFollowing(new SqlParserPos(0, 0)), null),
+        null,
         RelCollations.EMPTY,
         ImmutableList.of(
           new Window.RexWinAggCall(
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSelectivityTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSelectivityTest.scala
index eea6b0b433605..1fc2f71faeb13 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSelectivityTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSelectivityTest.scala
@@ -520,6 +520,7 @@ class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
         true,
         RexWindowBounds.create(SqlWindow.createUnboundedPreceding(new SqlParserPos(0, 0)), null),
         RexWindowBounds.create(SqlWindow.createCurrentRow(new SqlParserPos(0, 0)), null),
+        null,
         RelCollations.of(
           new RelFieldCollation(
             1,
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUpsertKeysTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUpsertKeysTest.scala
index 996ef4f2de8bf..4a77662bd2b70 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUpsertKeysTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUpsertKeysTest.scala
@@ -571,6 +571,7 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
         true,
         RexWindowBounds.create(SqlWindow.createUnboundedPreceding(new SqlParserPos(0, 0)), null),
         RexWindowBounds.create(SqlWindow.createCurrentRow(new SqlParserPos(0, 0)), null),
+        null,
         RelCollations.of(
           new RelFieldCollation(
             2,
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/FlinkPruneEmptyRulesTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/FlinkPruneEmptyRulesTest.scala
index 74e9ad050fea3..11258852f29a2 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/FlinkPruneEmptyRulesTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/FlinkPruneEmptyRulesTest.scala
@@ -47,7 +47,7 @@ class FlinkPruneEmptyRulesTest extends TableTestBase {
           CoreRules.FILTER_REDUCE_EXPRESSIONS,
           CoreRules.PROJECT_REDUCE_EXPRESSIONS,
           CoreRules.FILTER_SET_OP_TRANSPOSE,
-          CoreRules.FILTER_PROJECT_TRANSPOSE,
+          FlinkFilterProjectTransposeRule.INSTANCE,
           CoreRules.PROJECT_MERGE,
           CoreRules.PROJECT_FILTER_VALUES_MERGE,
           FlinkPruneEmptyRules.UNION_INSTANCE,
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.scala
index 7ecef1016c0d1..065f5b97c7750 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.scala
@@ -737,7 +737,7 @@ class SubQueryAntiJoinTest extends SubQueryTestBase {
     // TODO some bugs in SubQueryRemoveRule
     //  the result RelNode (LogicalJoin(condition=[=($1, $11)], joinType=[left]))
     //  after SubQueryRemoveRule is unexpected
-    assertThatExceptionOfType(classOf[AssertionError])
+    assertThatExceptionOfType(classOf[NullPointerException])
       .isThrownBy(() => util.verifyRelPlanNotExpected(sqlQuery, "joinType=[anti]"))
   }
 
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.scala
index 5b0802ccf59f8..809ac66c577c2 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.scala
@@ -964,25 +964,9 @@ class SubQuerySemiJoinTest extends SubQueryTestBase {
 
   @Test
   def testInWithCorrelatedOnHaving(): Unit = {
-    // TODO There are some bugs when converting SqlNode to RelNode:
     val sqlQuery = "SELECT SUM(a) AS s FROM x GROUP BY b " +
       "HAVING MAX(a) IN (SELECT d FROM y WHERE y.d = x.b)"
-
-    // the logical plan is:
-    //
-    // LogicalProject(s=[$1])
-    //  LogicalFilter(condition=[IN($2, {
-    //   LogicalProject(d=[$1])
-    //    LogicalFilter(condition=[=($1, $cor0.b)])
-    //     LogicalTableScan(table=[[builtin, default, r]])
-    //  })])
-    //   LogicalAggregate(group=[{0}], s=[SUM($1)], agg#1=[MAX($1)])
-    //    LogicalProject(b=[$1], a=[$0])
-    //     LogicalTableScan(table=[[builtin, default, l]])
-    //
-    // LogicalFilter lost variablesSet information.
-
-    util.verifyRelPlanNotExpected(sqlQuery, "joinType=[semi]")
+    util.verifyRelPlan(sqlQuery)
   }
 
   @Test
@@ -1622,25 +1606,9 @@ class SubQuerySemiJoinTest extends SubQueryTestBase {
 
   @Test
   def testExistsWithCorrelatedOnHaving(): Unit = {
-    // TODO There are some bugs when converting SqlNode to RelNode:
-    val sqlQuery1 =
+    val sqlQuery =
       "SELECT SUM(a) AS s FROM x GROUP BY b HAVING EXISTS (SELECT * FROM y WHERE y.d = x.b)"
-
-    // the logical plan is:
-    //
-    // LogicalProject(s=[$1])
-    //  LogicalFilter(condition=[IN($2, {
-    //   LogicalProject(d=[$1])
-    //    LogicalFilter(condition=[=($1, $cor0.b)])
-    //     LogicalTableScan(table=[[builtin, default, r]])
-    //  })])
-    //   LogicalAggregate(group=[{0}], s=[SUM($1)], agg#1=[MAX($1)])
-    //    LogicalProject(b=[$1], a=[$0])
-    //     LogicalTableScan(table=[[builtin, default, l]])
-    //
-    // LogicalFilter lost variablesSet information.
-
-    util.verifyRelPlanNotExpected(sqlQuery1, "joinType=[semi]")
+    util.verifyRelPlan(sqlQuery)
   }
 
   @Test
@@ -1711,7 +1679,7 @@ class SubQuerySemiJoinTest extends SubQueryTestBase {
     // TODO some bugs in SubQueryRemoveRule
     //  the result RelNode (LogicalJoin(condition=[=($1, $8)], joinType=[left]))
     //  after SubQueryRemoveRule is unexpected
-    assertThatExceptionOfType(classOf[AssertionError])
+    assertThatExceptionOfType(classOf[NullPointerException])
       .isThrownBy(() => util.verifyRelPlanNotExpected(sqlQuery, "joinType=[semi]"))
   }
 
diff --git a/flink-table/pom.xml b/flink-table/pom.xml
index 476e911568487..eacd06e2cc1ce 100644
--- a/flink-table/pom.xml
+++ b/flink-table/pom.xml
@@ -79,7 +79,7 @@ under the License.
 	</dependencyManagement>
 
 	<properties>
-		<calcite.version>1.37.0</calcite.version>
+		<calcite.version>1.38.0</calcite.version>
 		<janino.version>3.1.11</janino.version>
 		<guava.version>33.4.0-jre</guava.version>
 		<quartz.version>2.5.2</quartz.version>

From e7ad03281274c4c95cedfe8e220b887b54a37c2c Mon Sep 17 00:00:00 2001
From: Sergey Nuyanzin <snuyanzin@gmail.com>
Date: Thu, 28 May 2026 13:50:12 +0200
Subject: [PATCH 2/5] [FLINK-36602][tests] Replace deprecated `JavaConversions`
 in `FlinkRelMdHandlerTest` and its children

---
 .../FlinkRelMdColumnIntervalTest.scala        |  36 +-
 .../FlinkRelMdColumnNullCountTest.scala       |  11 +-
 .../FlinkRelMdColumnOriginNullCountTest.scala |  11 +-
 .../FlinkRelMdColumnUniquenessTest.scala      |   4 +-
 .../FlinkRelMdDistinctRowCountTest.scala      |   5 +-
 .../metadata/FlinkRelMdDistributionTest.scala |  18 +-
 ...FlinkRelMdFilteredColumnIntervalTest.scala |   5 +-
 .../metadata/FlinkRelMdHandlerTestBase.scala  | 345 ++++++++++--------
 .../FlinkRelMdModifiedMonotonicityTest.scala  |  11 +-
 .../metadata/FlinkRelMdRowCollationTest.scala |  24 +-
 .../metadata/FlinkRelMdRowCountTest.scala     |   4 +-
 .../metadata/FlinkRelMdSelectivityTest.scala  |  29 +-
 .../plan/metadata/FlinkRelMdSizeTest.scala    | 106 +++---
 .../metadata/FlinkRelMdUniqueGroupsTest.scala |  24 +-
 .../metadata/FlinkRelMdUniqueKeysTest.scala   | 173 +++++----
 .../metadata/FlinkRelMdUpsertKeysTest.scala   | 183 +++++-----
 16 files changed, 533 insertions(+), 456 deletions(-)

diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnIntervalTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnIntervalTest.scala
index aab16f95d4c9f..1902cf6e4be06 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnIntervalTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnIntervalTest.scala
@@ -27,7 +27,7 @@ import org.apache.flink.table.types.logical.IntType
 import org.apache.calcite.rel.RelDistributions
 import org.apache.calcite.rel.core.JoinRelType
 import org.apache.calcite.rel.logical.LogicalExchange
-import org.apache.calcite.rex.{RexCall, RexUtil}
+import org.apache.calcite.rex.{RexCall, RexNode, RexUtil}
 import org.apache.calcite.sql.fun.SqlStdOperatorTable._
 import org.apache.calcite.util.{DateString, TimestampString, TimeString}
 import org.junit.jupiter.api.Assertions._
@@ -35,8 +35,6 @@ import org.junit.jupiter.api.Test
 
 import java.sql.{Date, Time, Timestamp}
 
-import scala.collection.JavaConversions._
-
 class FlinkRelMdColumnIntervalTest extends FlinkRelMdHandlerTestBase {
 
   @Test
@@ -238,7 +236,11 @@ class FlinkRelMdColumnIntervalTest extends FlinkRelMdHandlerTestBase {
     val expr7 = relBuilder.call(GREATER_THAN, relBuilder.field(2), relBuilder.literal(1.9d))
 
     // calc => projects + filter(id <= 20)
-    val calc1 = createLogicalCalc(studentLogicalScan, outputRowType, projects, List(expr1))
+    val calc1 = createLogicalCalc(
+      studentLogicalScan,
+      outputRowType,
+      projects,
+      java.util.List.of[RexNode](expr1))
     assertEquals(ValueInterval(bd(0), bd(20)), mq.getColumnInterval(calc1, 0))
     assertNull(mq.getColumnInterval(calc1, 1))
     assertEqualsAsDouble(ValueInterval(bd(2.9), bd(5.0)), mq.getColumnInterval(calc1, 2))
@@ -254,7 +256,11 @@ class FlinkRelMdColumnIntervalTest extends FlinkRelMdHandlerTestBase {
 
     // calc => project + filter(id <= 20 AND id > 10 AND DIV(id, 2) > 3)
     val calc2 =
-      createLogicalCalc(studentLogicalScan, outputRowType, projects, List(expr1, expr2, expr3))
+      createLogicalCalc(
+        studentLogicalScan,
+        outputRowType,
+        projects,
+        java.util.List.of(expr1, expr2, expr3))
     assertEquals(
       ValueInterval(bd(10), bd(20), includeLower = false),
       mq.getColumnInterval(calc2, 0))
@@ -262,7 +268,11 @@ class FlinkRelMdColumnIntervalTest extends FlinkRelMdHandlerTestBase {
 
     // calc => project + filter(id <= 20 AND id > 10 AND score < 4.1)
     val calc3 =
-      createLogicalCalc(studentLogicalScan, outputRowType, projects, List(expr1, expr2, expr4))
+      createLogicalCalc(
+        studentLogicalScan,
+        outputRowType,
+        projects,
+        java.util.List.of(expr1, expr2, expr4))
     assertEquals(
       ValueInterval(bd(10), bd(20), includeLower = false),
       mq.getColumnInterval(calc3, 0))
@@ -272,7 +282,7 @@ class FlinkRelMdColumnIntervalTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       outputRowType,
       projects,
-      List(relBuilder.call(OR, expr5, expr6)))
+      java.util.List.of[RexNode](relBuilder.call(OR, expr5, expr6)))
     assertEqualsAsDouble(ValueInterval(bd(2.9), bd(5.0)), mq.getColumnInterval(calc4, 2))
 
     // calc => project + filter(score > 6.0 OR score <= 4.0 OR id < 20)
@@ -280,7 +290,7 @@ class FlinkRelMdColumnIntervalTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       outputRowType,
       projects,
-      List(relBuilder.call(OR, expr5, expr6, expr1)))
+      java.util.List.of[RexNode](relBuilder.call(OR, expr5, expr6, expr1)))
     assertEqualsAsDouble(ValueInterval(bd(2.9), bd(5.0)), mq.getColumnInterval(calc5, 2))
 
     // calc => project + filter((id <= 20 AND score < 4.1) OR NOT(DIV(id, 2) > 3 OR score > 1.9))
@@ -288,7 +298,7 @@ class FlinkRelMdColumnIntervalTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       outputRowType,
       projects,
-      List(
+      java.util.List.of[RexNode](
         relBuilder.call(
           OR,
           relBuilder.call(AND, expr1, expr4),
@@ -301,7 +311,7 @@ class FlinkRelMdColumnIntervalTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       outputRowType,
       projects,
-      List(
+      java.util.List.of[RexNode](
         relBuilder.call(
           OR,
           relBuilder.call(AND, expr1, expr4),
@@ -331,7 +341,11 @@ class FlinkRelMdColumnIntervalTest extends FlinkRelMdHandlerTestBase {
       Array("f0", "f1", "f2", "f3"),
       Array(new IntType(), new IntType(), new IntType(), new IntType()))
     val calc8 =
-      createLogicalCalc(studentLogicalScan, rowType, List(expr8, expr9, expr10, expr11), List())
+      createLogicalCalc(
+        studentLogicalScan,
+        rowType,
+        java.util.List.of(expr8, expr9, expr10, expr11),
+        java.util.List.of())
 
     assertEquals(ValueInterval(bd(0), bd(1)), mq.getColumnInterval(calc8, 0))
     assertEquals(ValueInterval(bd(10), bd(12)), mq.getColumnInterval(calc8, 1))
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnNullCountTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnNullCountTest.scala
index 9d7a4073c8f08..4d4af154745d1 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnNullCountTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnNullCountTest.scala
@@ -18,12 +18,11 @@
 package org.apache.flink.table.planner.plan.metadata
 
 import org.apache.calcite.rel.core.JoinRelType
+import org.apache.calcite.rex.RexNode
 import org.apache.calcite.sql.fun.SqlStdOperatorTable._
 import org.junit.jupiter.api.Assertions._
 import org.junit.jupiter.api.Test
 
-import scala.collection.JavaConversions._
-
 class FlinkRelMdColumnNullCountTest extends FlinkRelMdHandlerTestBase {
 
   @Test
@@ -126,7 +125,7 @@ class FlinkRelMdColumnNullCountTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       studentLogicalScan.getRowType,
       relBuilder.fields(),
-      List(expr1))
+      java.util.List.of[RexNode](expr1))
     assertEquals(0.0, mq.getColumnNullCount(calc2, 0))
     assertEquals(0.0, mq.getColumnNullCount(calc2, 1))
     assertNull(mq.getColumnNullCount(calc2, 2))
@@ -141,7 +140,7 @@ class FlinkRelMdColumnNullCountTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       studentLogicalScan.getRowType,
       relBuilder.fields(),
-      List(expr2))
+      java.util.List.of[RexNode](expr2))
     assertEquals(0.0, mq.getColumnNullCount(calc3, 0))
     assertEquals(0.0, mq.getColumnNullCount(calc3, 1))
     assertNull(mq.getColumnNullCount(calc3, 2))
@@ -156,7 +155,7 @@ class FlinkRelMdColumnNullCountTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       logicalProject.getRowType,
       logicalProject.getProjects,
-      List(expr1))
+      java.util.List.of[RexNode](expr1))
     assertEquals(0.0, mq.getColumnNullCount(calc4, 0))
     assertEquals(0.0, mq.getColumnNullCount(calc4, 1))
     assertNull(mq.getColumnNullCount(calc4, 2))
@@ -175,7 +174,7 @@ class FlinkRelMdColumnNullCountTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       logicalProject.getRowType,
       logicalProject.getProjects,
-      List(expr2))
+      java.util.List.of[RexNode](expr2))
     assertEquals(0.0, mq.getColumnNullCount(calc5, 0))
     assertEquals(0.0, mq.getColumnNullCount(calc5, 1))
     assertNull(mq.getColumnNullCount(calc5, 2))
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnOriginNullCountTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnOriginNullCountTest.scala
index ef23c4858dda1..4a137ce040fc7 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnOriginNullCountTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnOriginNullCountTest.scala
@@ -18,12 +18,11 @@
 package org.apache.flink.table.planner.plan.metadata
 
 import org.apache.calcite.rel.core.JoinRelType
+import org.apache.calcite.rex.RexNode
 import org.apache.calcite.sql.fun.SqlStdOperatorTable.{EQUALS, LESS_THAN_OR_EQUAL}
 import org.junit.jupiter.api.Assertions._
 import org.junit.jupiter.api.Test
 
-import scala.collection.JavaConversions._
-
 class FlinkRelMdColumnOriginNullCountTest extends FlinkRelMdHandlerTestBase {
 
   @Test
@@ -69,7 +68,7 @@ class FlinkRelMdColumnOriginNullCountTest extends FlinkRelMdHandlerTestBase {
 
     val ts = relBuilder.scan("MyTable3").build()
     relBuilder.push(ts)
-    val projects = List(
+    val projects = java.util.List.of(
       relBuilder.call(EQUALS, relBuilder.field(0), relBuilder.literal(1)),
       relBuilder.field(0),
       relBuilder.field(1),
@@ -95,14 +94,14 @@ class FlinkRelMdColumnOriginNullCountTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       studentLogicalScan.getRowType,
       relBuilder.fields(),
-      List(expr))
+      java.util.List.of[RexNode](expr))
     (0 until calc1.getRowType.getFieldCount).foreach {
       idx => assertNull(mq.getColumnOriginNullCount(calc1, idx))
     }
 
     val ts = relBuilder.scan("MyTable3").build()
     relBuilder.push(ts)
-    val projects = List(
+    val projects = java.util.List.of(
       relBuilder.call(EQUALS, relBuilder.field(0), relBuilder.literal(1)),
       relBuilder.field(0),
       relBuilder.field(1),
@@ -110,7 +109,7 @@ class FlinkRelMdColumnOriginNullCountTest extends FlinkRelMdHandlerTestBase {
       relBuilder.literal(null)
     )
     val outputRowType = relBuilder.project(projects).build().getRowType
-    val calc2 = createLogicalCalc(ts, outputRowType, projects, List())
+    val calc2 = createLogicalCalc(ts, outputRowType, projects, java.util.List.of())
     assertEquals(null, mq.getColumnOriginNullCount(calc2, 0))
     assertEquals(1.0, mq.getColumnOriginNullCount(calc2, 1))
     assertEquals(0.0, mq.getColumnOriginNullCount(calc2, 2))
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniquenessTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniquenessTest.scala
index 57920d5d6ccc9..49d07882c63f4 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniquenessTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniquenessTest.scala
@@ -29,8 +29,6 @@ import org.apache.calcite.util.ImmutableBitSet
 import org.junit.jupiter.api.Assertions._
 import org.junit.jupiter.api.Test
 
-import scala.collection.JavaConversions._
-
 class FlinkRelMdColumnUniquenessTest extends FlinkRelMdHandlerTestBase {
 
   @Test
@@ -93,7 +91,7 @@ class FlinkRelMdColumnUniquenessTest extends FlinkRelMdHandlerTestBase {
 
     // project: id, cast(id as long not null), name, cast(name as varchar not null)
     relBuilder.push(studentLogicalScan)
-    val exprs = List(
+    val exprs = java.util.List.of(
       relBuilder.field(0),
       relBuilder.cast(relBuilder.field(0), BIGINT),
       relBuilder.field(1),
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistinctRowCountTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistinctRowCountTest.scala
index 568307603f898..4beb3b1802ad6 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistinctRowCountTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistinctRowCountTest.scala
@@ -20,13 +20,12 @@ package org.apache.flink.table.planner.plan.metadata
 import org.apache.flink.table.planner.plan.nodes.physical.batch.BatchPhysicalRank
 import org.apache.flink.table.planner.plan.utils.FlinkRelMdUtil
 
+import org.apache.calcite.rex.RexNode
 import org.apache.calcite.sql.fun.SqlStdOperatorTable._
 import org.apache.calcite.util.ImmutableBitSet
 import org.junit.jupiter.api.Assertions._
 import org.junit.jupiter.api.Test
 
-import scala.collection.JavaConversions._
-
 class FlinkRelMdDistinctRowCountTest extends FlinkRelMdHandlerTestBase {
 
   @Test
@@ -187,7 +186,7 @@ class FlinkRelMdDistinctRowCountTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       logicalProject.getRowType,
       logicalProject.getProjects,
-      List(expr1))
+      java.util.List.of[RexNode](expr1))
 
     assertEquals(1.0, mq.getDistinctRowCount(calc, ImmutableBitSet.of(), null))
     assertEquals(25.0, mq.getDistinctRowCount(calc, ImmutableBitSet.of(0), null))
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistributionTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistributionTest.scala
index 0b741f2fb22e7..b8325f725f625 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistributionTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistributionTest.scala
@@ -24,12 +24,11 @@ import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamPhysicalD
 import org.apache.flink.table.types.logical.{BigIntType, DoubleType}
 
 import com.google.common.collect.ImmutableList
+import org.apache.calcite.rex.RexNode
 import org.apache.calcite.sql.fun.SqlStdOperatorTable._
 import org.junit.jupiter.api.Assertions._
 import org.junit.jupiter.api.Test
 
-import scala.collection.JavaConversions._
-
 class FlinkRelMdDistributionTest extends FlinkRelMdHandlerTestBase {
 
   @Test
@@ -70,7 +69,11 @@ class FlinkRelMdDistributionTest extends FlinkRelMdHandlerTestBase {
     relBuilder.push(scan1)
     val expr4 = relBuilder.call(LESS_THAN, relBuilder.field(4), relBuilder.literal(170.0))
     val calc =
-      createLogicalCalc(scan1, logicalProject.getRowType, logicalProject.getProjects, List(expr4))
+      createLogicalCalc(
+        scan1,
+        logicalProject.getRowType,
+        logicalProject.getProjects,
+        java.util.List.of[RexNode](expr4))
     assertEquals(
       FlinkRelDistribution.hash(Array(6), requireStrict = false),
       mq.flinkDistribution(calc))
@@ -80,7 +83,7 @@ class FlinkRelMdDistributionTest extends FlinkRelMdHandlerTestBase {
       createDataStreamScan(ImmutableList.of("student"), flinkLogicalTraits.replace(distribution01))
     relBuilder.push(scan2)
     // projects: $0==1, $0, $1, true, 2.1, 2
-    val projects1 = List(
+    val projects1 = java.util.List.of(
       relBuilder.call(EQUALS, relBuilder.field(0), relBuilder.literal(1)),
       relBuilder.field(0),
       relBuilder.field(1),
@@ -92,13 +95,14 @@ class FlinkRelMdDistributionTest extends FlinkRelMdHandlerTestBase {
     relBuilder.push(scan2)
     val expr1 = relBuilder.call(LESS_THAN_OR_EQUAL, relBuilder.field(0), relBuilder.literal(2))
     // calc => projects + filter: $0 <= 2
-    val calc1 = createLogicalCalc(scan2, outputRowType, projects1, List(expr1))
+    val calc1 =
+      createLogicalCalc(scan2, outputRowType, projects1, java.util.List.of[RexNode](expr1))
     assertEquals(
       FlinkRelDistribution.hash(Array(1, 2), requireStrict = false),
       mq.flinkDistribution(calc1))
 
     // projects: $0==1, $0, 2.1, true, 2.1, 2
-    val projects2 = List(
+    val projects2 = java.util.List.of(
       relBuilder.call(EQUALS, relBuilder.field(0), relBuilder.literal(1)),
       relBuilder.field(0),
       makeLiteral(2.1, new DoubleType(), isNullable = false, allowCast = true),
@@ -106,7 +110,7 @@ class FlinkRelMdDistributionTest extends FlinkRelMdHandlerTestBase {
       makeLiteral(2.1, new DoubleType(), isNullable = false, allowCast = true),
       makeLiteral(2L, new BigIntType(), isNullable = false, allowCast = true)
     )
-    val calc2 = createLogicalCalc(scan2, outputRowType, projects2, List())
+    val calc2 = createLogicalCalc(scan2, outputRowType, projects2, java.util.List.of())
     assertEquals(FlinkRelDistribution.ANY, mq.flinkDistribution(calc2))
   }
 
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnIntervalTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnIntervalTest.scala
index 6ea6a129fa1ec..96a24e332fa39 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnIntervalTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnIntervalTest.scala
@@ -26,7 +26,7 @@ import org.apache.calcite.sql.fun.SqlStdOperatorTable.{DIVIDE, EQUALS, GREATER_T
 import org.junit.jupiter.api.{BeforeEach, Test}
 import org.junit.jupiter.api.Assertions.{assertEquals, assertNull}
 
-import scala.collection.JavaConversions._
+import scala.collection.JavaConverters.seqAsJavaListConverter
 
 class FlinkRelMdFilteredColumnIntervalTest extends FlinkRelMdHandlerTestBase {
   private var ts: RelNode = _
@@ -202,7 +202,8 @@ class FlinkRelMdFilteredColumnIntervalTest extends FlinkRelMdHandlerTestBase {
         new BooleanType()
       )
     )
-    val calc = createLogicalCalc(ts, outputRowType, projects, List(expr1))
+    val calc =
+      createLogicalCalc(ts, outputRowType, projects.asJava, java.util.List.of[RexNode](expr1))
     assertEquals(ValueInterval(bd(-5), bd(2)), mq.getFilteredColumnInterval(calc, 0, -1))
     assertEquals(ValueInterval(bd(0d), bd(6.1d)), mq.getFilteredColumnInterval(calc, 1, -1))
     assertEquals(ValueInterval(bd(-5), bd(2)), mq.getFilteredColumnInterval(calc, 0, 2))
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
index d8815d3aa6bf7..2662d3c3139ad 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
@@ -77,7 +77,7 @@ import java.time.Duration
 import java.util
 import java.util.Collections
 
-import scala.collection.JavaConversions._
+import scala.collection.JavaConverters.{collectionAsScalaIterableConverter, seqAsJavaListConverter}
 
 class FlinkRelMdHandlerTestBase {
 
@@ -177,11 +177,20 @@ class FlinkRelMdHandlerTestBase {
     createTableSourceTable(ImmutableList.of("TableSourceTable1"), streamPhysicalTraits)
 
   protected lazy val flinkLogicalIntermediateTableScan: FlinkLogicalIntermediateTableScan =
-    createIntermediateScan(streamExchangeById, flinkLogicalTraits, Set(ImmutableBitSet.of(0)))
+    createIntermediateScan(
+      streamExchangeById,
+      flinkLogicalTraits,
+      java.util.Set.of[ImmutableBitSet](ImmutableBitSet.of(0)))
   protected lazy val batchPhysicalIntermediateTableScan: BatchPhysicalIntermediateTableScan =
-    createIntermediateScan(batchExchangeById, batchPhysicalTraits, Set(ImmutableBitSet.of(0)))
+    createIntermediateScan(
+      batchExchangeById,
+      batchPhysicalTraits,
+      java.util.Set.of[ImmutableBitSet](ImmutableBitSet.of(0)))
   protected lazy val streamPhysicalIntermediateTableScan: StreamPhysicalIntermediateTableScan =
-    createIntermediateScan(streamExchangeById, streamPhysicalTraits, Set(ImmutableBitSet.of(0)))
+    createIntermediateScan(
+      streamExchangeById,
+      streamPhysicalTraits,
+      java.util.Set.of[ImmutableBitSet](ImmutableBitSet.of(0)))
 
   protected lazy val tablePartiallyProjectedKeyLogicalScan: LogicalTableScan =
     createTableSourceTable(
@@ -248,7 +257,7 @@ class FlinkRelMdHandlerTestBase {
       List(null, "false", "2017-09-01", "10:00:01", null, "3.12", null, null),
       List("3", "true", null, "10:00:02", "2017-10-01 01:00:00", "3.0", null, "xyz"),
       List("2", "true", "2017-10-02", "09:59:59", "2017-07-01 01:00:00", "-1", null, "F")
-    ).map(createLiteralList(valuesType, _))
+    ).map(createLiteralList(valuesType, _)).asJava
     relBuilder.values(tupleList, valuesType)
     relBuilder.build().asInstanceOf[LogicalValues]
   }
@@ -257,7 +266,7 @@ class FlinkRelMdHandlerTestBase {
   // case sex = 'M' then 1 else 2, true, 2.1, 2, cast(score as double not null) as s from student
   protected lazy val logicalProject: LogicalProject = {
     relBuilder.push(studentLogicalScan)
-    val projects = List(
+    val projects = java.util.List.of(
       // id
       relBuilder.field(0),
       // name
@@ -304,7 +313,7 @@ class FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       logicalProject.getRowType,
       logicalProject.getProjects,
-      List(expr))
+      java.util.List.of[RexNode](expr))
     (filter, calc)
   }
 
@@ -383,7 +392,12 @@ class FlinkRelMdHandlerTestBase {
   }
 
   protected lazy val intermediateTable =
-    new IntermediateRelTable(Seq(""), streamExchangeById, null, false, Set(ImmutableBitSet.of(0)))
+    new IntermediateRelTable(
+      java.util.List.of[String](""),
+      streamExchangeById,
+      null,
+      false,
+      java.util.Set.of[ImmutableBitSet](ImmutableBitSet.of(0)))
 
   protected lazy val intermediateScan = new FlinkLogicalIntermediateTableScan(
     cluster,
@@ -403,7 +417,7 @@ class FlinkRelMdHandlerTestBase {
   protected def createSorts(sortKeys: () => Seq[RexNode]): (RelNode, RelNode, RelNode, RelNode) = {
     val logicalSort = relBuilder
       .scan("student")
-      .sort(sortKeys())
+      .sort(sortKeys().asJava)
       .build
       .asInstanceOf[LogicalSort]
     val collation = logicalSort.getCollation
@@ -513,7 +527,7 @@ class FlinkRelMdHandlerTestBase {
       sortKeys: () => Seq[RexNode]): (RelNode, RelNode, RelNode, RelNode, RelNode, RelNode) = {
     val logicalSortLimit = relBuilder
       .scan("student")
-      .sort(sortKeys())
+      .sort(sortKeys().asJava)
       .limit(10, 20)
       .build
       .asInstanceOf[LogicalSort]
@@ -873,10 +887,10 @@ class FlinkRelMdHandlerTestBase {
     )
 
     val builder = typeFactory.builder()
-    firstRow.getRowType.getFieldList.dropRight(2).foreach(builder.add)
+    firstRow.getRowType.getFieldList.asScala.dropRight(2).foreach(builder.add)
     val projectProgram = RexProgram.create(
       firstRow.getRowType,
-      Array(0, 1, 2).map(i => RexInputRef.of(i, firstRow.getRowType)).toList,
+      Array(0, 1, 2).map(i => RexInputRef.of(i, firstRow.getRowType)).toList.asJava,
       null,
       builder.build(),
       rexBuilder
@@ -1016,8 +1030,8 @@ class FlinkRelMdHandlerTestBase {
       false,
       false,
       false,
-      Seq().toList,
-      Seq(Integer.valueOf(3)).toList,
+      java.util.List.of[RexNode](),
+      java.util.List.of[Integer](Integer.valueOf(3)),
       -1,
       null,
       RelCollations.of(),
@@ -1034,7 +1048,7 @@ class FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       ImmutableBitSet.of(0),
       null,
-      Seq(tableAggCall))
+      Seq(tableAggCall).asJava)
 
     val flinkLogicalTableAgg = new FlinkLogicalTableAggregate(
       cluster,
@@ -1042,7 +1056,7 @@ class FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       ImmutableBitSet.of(0),
       null,
-      Seq(tableAggCall)
+      Seq(tableAggCall).asJava
     )
 
     val builder = typeFactory.builder()
@@ -1075,7 +1089,7 @@ class FlinkRelMdHandlerTestBase {
     relBuilder.scan("TemporalTable1")
     val ts = relBuilder.peek()
     val project = relBuilder
-      .project(relBuilder.fields(Seq[Integer](2, 0, 1, 4).toList))
+      .project(relBuilder.fields(Seq[Integer](2, 0, 1, 4).toList.asJava))
       .build()
       .asInstanceOf[Project]
     val program =
@@ -1122,9 +1136,9 @@ class FlinkRelMdHandlerTestBase {
       streamExchange,
       flinkLogicalWindowAgg.getRowType,
       Array(1),
-      flinkLogicalWindowAgg.getAggCallList,
+      flinkLogicalWindowAgg.getAggCallList.asScala.toSeq,
       tumblingGroupWindow,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       emitStrategy
     )
 
@@ -1170,11 +1184,11 @@ class FlinkRelMdHandlerTestBase {
       logicalAgg.getAggCallList
     )
 
-    val aggCalls = logicalAgg.getAggCallList
+    val aggCalls = logicalAgg.getAggCallList.asScala
     val aggFunctionFactory = new AggFunctionFactory(
       FlinkTypeFactory.toLogicalRowType(studentBatchScan.getRowType),
       Array.empty[Int],
-      Array.fill(aggCalls.size())(false),
+      Array.fill(aggCalls.size)(false),
       false)
     val aggCallToAggFunction = aggCalls.zipWithIndex.map {
       case (call, index) => (call, aggFunctionFactory.createAggFunction(call, index))
@@ -1210,7 +1224,7 @@ class FlinkRelMdHandlerTestBase {
       Array(3),
       auxGrouping = Array(),
       true,
-      aggCallToAggFunction)
+      aggCallToAggFunction.toSeq)
 
     val batchExchange1 = new BatchPhysicalExchange(
       cluster,
@@ -1226,7 +1240,7 @@ class FlinkRelMdHandlerTestBase {
       batchLocalAgg.getInput.getRowType,
       Array(0),
       auxGrouping = Array(),
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       isMerge = true)
 
     val batchExchange2 = new BatchPhysicalExchange(
@@ -1243,17 +1257,17 @@ class FlinkRelMdHandlerTestBase {
       batchExchange2.getRowType,
       Array(3),
       auxGrouping = Array(),
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       isMerge = false)
 
     val aggCallNeedRetractions =
-      AggregateUtil.deriveAggCallNeedRetractions(1, aggCalls, needRetraction = false, null)
+      AggregateUtil.deriveAggCallNeedRetractions(1, aggCalls.toSeq, needRetraction = false, null)
     val streamLocalAgg = new StreamPhysicalLocalGroupAggregate(
       cluster,
       streamPhysicalTraits,
       studentStreamScan,
       Array(3),
-      aggCalls,
+      aggCalls.toSeq,
       aggCallNeedRetractions,
       false,
       PartialFinalType.NONE)
@@ -1269,7 +1283,7 @@ class FlinkRelMdHandlerTestBase {
       streamExchange1,
       rowTypeOfGlobalAgg,
       Array(0),
-      aggCalls,
+      aggCalls.toSeq,
       aggCallNeedRetractions,
       streamLocalAgg.getInput.getRowType,
       AggregateUtil.needRetraction(streamLocalAgg),
@@ -1286,7 +1300,7 @@ class FlinkRelMdHandlerTestBase {
       streamExchange2,
       rowTypeOfGlobalAgg,
       Array(3),
-      aggCalls)
+      aggCalls.toSeq)
 
     (
       logicalAgg,
@@ -1328,7 +1342,7 @@ class FlinkRelMdHandlerTestBase {
     streamGlobalAggWithoutLocalWithFilter) = {
 
     relBuilder.push(studentLogicalScan)
-    val projects = List(
+    val projects = java.util.List.of(
       relBuilder.field(0),
       relBuilder.field(1),
       relBuilder.field(2),
@@ -1371,7 +1385,7 @@ class FlinkRelMdHandlerTestBase {
         false,
         false,
         false,
-        List(Integer.valueOf(argIndex)),
+        java.util.List.of[Integer](Integer.valueOf(argIndex)),
         filterArg,
         null,
         RelCollations.EMPTY,
@@ -1401,10 +1415,10 @@ class FlinkRelMdHandlerTestBase {
 
     val logicalAggWithFilter = LogicalAggregate.create(
       calcOnStudentScan,
-      List(),
+      java.util.List.of[RelHint](),
       ImmutableBitSet.of(3),
-      List(ImmutableBitSet.of(3)),
-      aggCallList)
+      java.util.List.of[ImmutableBitSet](ImmutableBitSet.of(3)),
+      aggCallList.asJava)
 
     val flinkLogicalAggWithFilter = new FlinkLogicalAggregate(
       cluster,
@@ -1414,11 +1428,11 @@ class FlinkRelMdHandlerTestBase {
       logicalAggWithFilter.getGroupSets,
       logicalAggWithFilter.getAggCallList)
 
-    val aggCalls = logicalAggWithFilter.getAggCallList
+    val aggCalls = logicalAggWithFilter.getAggCallList.asScala
     val aggFunctionFactory = new AggFunctionFactory(
       FlinkTypeFactory.toLogicalRowType(calcOnStudentScan.getRowType),
       Array.empty[Int],
-      Array.fill(aggCalls.size())(false),
+      Array.fill(aggCalls.size)(false),
       false)
     val aggCallToAggFunction = aggCalls.zipWithIndex.map {
       case (call, index) => (call, aggFunctionFactory.createAggFunction(call, index))
@@ -1476,7 +1490,7 @@ class FlinkRelMdHandlerTestBase {
       Array(3),
       auxGrouping = Array(),
       true,
-      aggCallToAggFunction)
+      aggCallToAggFunction.toSeq)
 
     val batchExchange1 = new BatchPhysicalExchange(
       cluster,
@@ -1492,7 +1506,7 @@ class FlinkRelMdHandlerTestBase {
       batchLocalAggWithFilter.getInput.getRowType,
       Array(0),
       auxGrouping = Array(),
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       isMerge = true)
 
     val batchExchange2 = new BatchPhysicalExchange(
@@ -1509,17 +1523,17 @@ class FlinkRelMdHandlerTestBase {
       batchExchange2.getRowType,
       Array(3),
       auxGrouping = Array(),
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       isMerge = false)
 
     val aggCallNeedRetractions =
-      AggregateUtil.deriveAggCallNeedRetractions(1, aggCalls, needRetraction = false, null)
+      AggregateUtil.deriveAggCallNeedRetractions(1, aggCalls.toSeq, needRetraction = false, null)
     val streamLocalAggWithFilter = new StreamPhysicalLocalGroupAggregate(
       cluster,
       streamPhysicalTraits,
       calcOnStudentScan,
       Array(3),
-      aggCalls,
+      aggCalls.toSeq,
       aggCallNeedRetractions,
       false,
       PartialFinalType.NONE)
@@ -1535,7 +1549,7 @@ class FlinkRelMdHandlerTestBase {
       streamExchange1,
       rowTypeOfGlobalAgg,
       Array(0),
-      aggCalls,
+      aggCalls.toSeq,
       aggCallNeedRetractions,
       streamLocalAggWithFilter.getInput.getRowType,
       AggregateUtil.needRetraction(streamLocalAggWithFilter),
@@ -1552,7 +1566,7 @@ class FlinkRelMdHandlerTestBase {
       streamExchange2,
       rowTypeOfGlobalAgg,
       Array(3),
-      aggCalls)
+      aggCalls.toSeq)
 
     (
       logicalAggWithFilter,
@@ -1599,13 +1613,13 @@ class FlinkRelMdHandlerTestBase {
       logicalAggWithAuxGroup.getAggCallList
     )
 
-    val aggCalls = logicalAggWithAuxGroup.getAggCallList.filter {
+    val aggCalls = logicalAggWithAuxGroup.getAggCallList.asScala.filter {
       call => call.getAggregation != FlinkSqlOperatorTable.AUXILIARY_GROUP
     }
     val aggFunctionFactory = new AggFunctionFactory(
       FlinkTypeFactory.toLogicalRowType(studentBatchScan.getRowType),
       Array.empty[Int],
-      Array.fill(aggCalls.size())(false),
+      Array.fill(aggCalls.size)(false),
       false)
     val aggCallToAggFunction = aggCalls.zipWithIndex.map {
       case (call, index) => (call, aggFunctionFactory.createAggFunction(call, index))
@@ -1629,7 +1643,7 @@ class FlinkRelMdHandlerTestBase {
       Array(0),
       auxGrouping = Array(1, 4),
       true,
-      aggCallToAggFunction)
+      aggCallToAggFunction.toSeq)
 
     val hash0 = FlinkRelDistribution.hash(Array(0), requireStrict = true)
     val batchExchange = new BatchPhysicalExchange(
@@ -1655,7 +1669,7 @@ class FlinkRelMdHandlerTestBase {
       batchLocalAggWithAuxGroup.getInput.getRowType,
       Array(0),
       auxGrouping = Array(1, 2),
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       isMerge = true)
 
     val batchExchange2 = new BatchPhysicalExchange(
@@ -1672,7 +1686,7 @@ class FlinkRelMdHandlerTestBase {
       batchExchange2.getRowType,
       Array(0),
       auxGrouping = Array(1, 4),
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       isMerge = false)
 
     (
@@ -1700,8 +1714,8 @@ class FlinkRelMdHandlerTestBase {
       intervalOfMillis(900000)
     )
 
-  protected lazy val namedPropertiesOfWindowAgg: Seq[NamedWindowProperty] =
-    Seq(
+  protected lazy val namedPropertiesOfWindowAgg: java.util.List[NamedWindowProperty] =
+    java.util.List.of(
       new NamedWindowProperty("w$start", new WindowStart(windowRef)),
       new NamedWindowProperty("w$end", new WindowStart(windowRef)),
       new NamedWindowProperty("w$rowtime", new RowtimeAttribute(windowRef)),
@@ -1725,7 +1739,7 @@ class FlinkRelMdHandlerTestBase {
     relBuilder.scan("TemporalTable1")
     val ts = relBuilder.peek()
     val project = relBuilder
-      .project(relBuilder.fields(Seq[Integer](0, 1, 4, 2).toList))
+      .project(relBuilder.fields(Seq[Integer](0, 1, 4, 2).toList.asJava))
       .build()
       .asInstanceOf[Project]
     val program =
@@ -1736,7 +1750,7 @@ class FlinkRelMdHandlerTestBase {
         false,
         false,
         false,
-        List[Integer](3),
+        java.util.List.of[Integer](3),
         -1,
         null,
         RelCollations.EMPTY,
@@ -1780,17 +1794,17 @@ class FlinkRelMdHandlerTestBase {
       AggregateUtil.transformToBatchAggregateFunctions(
         typeFactory,
         FlinkTypeFactory.toLogicalRowType(batchExchange1.getRowType),
-        flinkLogicalWindowAgg.getAggCallList)
-    val aggCallToAggFunction = flinkLogicalWindowAgg.getAggCallList.zip(aggregates)
+        flinkLogicalWindowAgg.getAggCallList.asScala.toSeq)
+    val aggCallToAggFunction = flinkLogicalWindowAgg.getAggCallList.asScala.zip(aggregates)
 
     val localWindowAggTypes =
       (Array(0, 1).map(batchCalc.getRowType.getFieldList.get(_).getType) ++ // grouping
         Array(longType) ++ // assignTs
-        aggCallOfWindowAgg.map(_.getType)).toList // agg calls
+        aggCallOfWindowAgg.asScala.map(_.getType)).toList.asJava // agg calls
     val localWindowAggNames =
       (Array(0, 1).map(batchCalc.getRowType.getFieldNames.get(_)) ++ // grouping
         Array("assignedWindow$") ++ // assignTs
-        Array("count$0")).toList // agg calls
+        Array("count$0")).toList.asJava // agg calls
     val localWindowAggRowType =
       typeFactory.createStructType(localWindowAggTypes, localWindowAggNames)
     val batchLocalWindowAgg = new BatchPhysicalLocalHashWindowAggregate(
@@ -1801,11 +1815,11 @@ class FlinkRelMdHandlerTestBase {
       batchCalc.getRowType,
       Array(0, 1),
       Array.empty,
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       tumblingGroupWindow,
       inputTimeFieldIndex = 2,
       inputTimeIsDate = false,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       enableAssignPane = false)
     val batchExchange2 = new BatchPhysicalExchange(
       cluster,
@@ -1820,11 +1834,11 @@ class FlinkRelMdHandlerTestBase {
       batchCalc.getRowType,
       Array(0, 1),
       Array.empty,
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       tumblingGroupWindow,
       inputTimeFieldIndex = 2,
       inputTimeIsDate = false,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       enableAssignPane = false,
       isMerge = true
     )
@@ -1837,11 +1851,11 @@ class FlinkRelMdHandlerTestBase {
       batchExchange1.getRowType,
       Array(0, 1),
       Array.empty,
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       tumblingGroupWindow,
       inputTimeFieldIndex = 2,
       inputTimeIsDate = false,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       enableAssignPane = false,
       isMerge = false
     )
@@ -1863,9 +1877,9 @@ class FlinkRelMdHandlerTestBase {
       streamExchange,
       flinkLogicalWindowAgg.getRowType,
       Array(0, 1),
-      flinkLogicalWindowAgg.getAggCallList,
+      flinkLogicalWindowAgg.getAggCallList.asScala.toSeq,
       tumblingGroupWindow,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       emitStrategy
     )
 
@@ -1895,7 +1909,7 @@ class FlinkRelMdHandlerTestBase {
     relBuilder.scan("TemporalTable1")
     val ts = relBuilder.peek()
     val project = relBuilder
-      .project(relBuilder.fields(Seq[Integer](0, 1, 4).toList))
+      .project(relBuilder.fields(Seq[Integer](0, 1, 4).toList.asJava))
       .build()
       .asInstanceOf[Project]
     val program =
@@ -1906,7 +1920,7 @@ class FlinkRelMdHandlerTestBase {
         false,
         false,
         false,
-        List[Integer](0),
+        java.util.List.of[Integer](0),
         -1,
         null,
         RelCollations.EMPTY,
@@ -1950,17 +1964,17 @@ class FlinkRelMdHandlerTestBase {
       AggregateUtil.transformToBatchAggregateFunctions(
         typeFactory,
         FlinkTypeFactory.toLogicalRowType(batchExchange1.getRowType),
-        flinkLogicalWindowAgg.getAggCallList)
-    val aggCallToAggFunction = flinkLogicalWindowAgg.getAggCallList.zip(aggregates)
+        flinkLogicalWindowAgg.getAggCallList.asScala.toSeq)
+    val aggCallToAggFunction = flinkLogicalWindowAgg.getAggCallList.asScala.zip(aggregates)
 
     val localWindowAggTypes =
       (Array(batchCalc.getRowType.getFieldList.get(1).getType) ++ // grouping
         Array(longType) ++ // assignTs
-        aggCallOfWindowAgg.map(_.getType)).toList // agg calls
+        aggCallOfWindowAgg.asScala.map(_.getType)).toList.asJava // agg calls
     val localWindowAggNames =
       (Array(batchCalc.getRowType.getFieldNames.get(1)) ++ // grouping
         Array("assignedWindow$") ++ // assignTs
-        Array("count$0")).toList // agg calls
+        Array("count$0")).toList.asJava // agg calls
     val localWindowAggRowType =
       typeFactory.createStructType(localWindowAggTypes, localWindowAggNames)
     val batchLocalWindowAgg = new BatchPhysicalLocalHashWindowAggregate(
@@ -1971,11 +1985,11 @@ class FlinkRelMdHandlerTestBase {
       batchCalc.getRowType,
       Array(1),
       Array.empty,
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       tumblingGroupWindow,
       inputTimeFieldIndex = 2,
       inputTimeIsDate = false,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       enableAssignPane = false)
     val batchExchange2 = new BatchPhysicalExchange(
       cluster,
@@ -1990,11 +2004,11 @@ class FlinkRelMdHandlerTestBase {
       batchCalc.getRowType,
       Array(0),
       Array.empty,
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       tumblingGroupWindow,
       inputTimeFieldIndex = 2,
       inputTimeIsDate = false,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       enableAssignPane = false,
       isMerge = true
     )
@@ -2007,11 +2021,11 @@ class FlinkRelMdHandlerTestBase {
       batchExchange1.getRowType,
       Array(1),
       Array.empty,
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       tumblingGroupWindow,
       inputTimeFieldIndex = 2,
       inputTimeIsDate = false,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       enableAssignPane = false,
       isMerge = false
     )
@@ -2033,9 +2047,9 @@ class FlinkRelMdHandlerTestBase {
       streamExchange,
       flinkLogicalWindowAgg.getRowType,
       Array(1),
-      flinkLogicalWindowAgg.getAggCallList,
+      flinkLogicalWindowAgg.getAggCallList.asScala.toSeq,
       tumblingGroupWindow,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       emitStrategy
     )
 
@@ -2064,7 +2078,7 @@ class FlinkRelMdHandlerTestBase {
     relBuilder.scan("TemporalTable2")
     val ts = relBuilder.peek()
     val project = relBuilder
-      .project(relBuilder.fields(Seq[Integer](0, 2, 4, 1).toList))
+      .project(relBuilder.fields(Seq[Integer](0, 2, 4, 1).toList.asJava))
       .build()
       .asInstanceOf[Project]
     val program =
@@ -2075,7 +2089,7 @@ class FlinkRelMdHandlerTestBase {
         false,
         false,
         false,
-        List[Integer](1),
+        java.util.List.of[Integer](1),
         -1,
         null,
         RelCollations.EMPTY,
@@ -2088,7 +2102,7 @@ class FlinkRelMdHandlerTestBase {
         false,
         false,
         false,
-        List[Integer](3),
+        java.util.List.of[Integer](3),
         -1,
         null,
         RelCollations.EMPTY,
@@ -2129,24 +2143,24 @@ class FlinkRelMdHandlerTestBase {
     val hash0 = FlinkRelDistribution.hash(Array(0), requireStrict = true)
     val batchExchange1 =
       new BatchPhysicalExchange(cluster, batchPhysicalTraits.replace(hash0), batchCalc, hash0)
-    val aggCallsWithoutAuxGroup = flinkLogicalWindowAggWithAuxGroup.getAggCallList.drop(1)
+    val aggCallsWithoutAuxGroup = flinkLogicalWindowAggWithAuxGroup.getAggCallList.asScala.drop(1)
     val (_, _, aggregates) =
       AggregateUtil.transformToBatchAggregateFunctions(
         typeFactory,
         FlinkTypeFactory.toLogicalRowType(batchExchange1.getRowType),
-        aggCallsWithoutAuxGroup)
+        aggCallsWithoutAuxGroup.toSeq)
     val aggCallToAggFunction = aggCallsWithoutAuxGroup.zip(aggregates)
 
     val localWindowAggTypes =
       (Array(batchCalc.getRowType.getFieldList.get(0).getType) ++ // grouping
         Array(longType) ++ // assignTs
         Array(batchCalc.getRowType.getFieldList.get(1).getType) ++ // auxGrouping
-        aggCallsWithoutAuxGroup.map(_.getType)).toList // agg calls
+        aggCallsWithoutAuxGroup.map(_.getType)).toList.asJava // agg calls
     val localWindowAggNames =
       (Array(batchCalc.getRowType.getFieldNames.get(0)) ++ // grouping
         Array("assignedWindow$") ++ // assignTs
         Array(batchCalc.getRowType.getFieldNames.get(1)) ++ // auxGrouping
-        Array("count$0")).toList // agg calls
+        Array("count$0")).toList.asJava // agg calls
     val localWindowAggRowType =
       typeFactory.createStructType(localWindowAggTypes, localWindowAggNames)
     val batchLocalWindowAggWithAuxGroup = new BatchPhysicalLocalHashWindowAggregate(
@@ -2157,11 +2171,11 @@ class FlinkRelMdHandlerTestBase {
       batchCalc.getRowType,
       Array(0),
       Array(1),
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       tumblingGroupWindow,
       inputTimeFieldIndex = 2,
       inputTimeIsDate = false,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       enableAssignPane = false)
     val batchExchange2 = new BatchPhysicalExchange(
       cluster,
@@ -2176,11 +2190,11 @@ class FlinkRelMdHandlerTestBase {
       batchCalc.getRowType,
       Array(0),
       Array(2), // local output grouping keys: grouping + assignTs + auxGrouping
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       tumblingGroupWindow,
       inputTimeFieldIndex = 2,
       inputTimeIsDate = false,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       enableAssignPane = false,
       isMerge = true
     )
@@ -2193,11 +2207,11 @@ class FlinkRelMdHandlerTestBase {
       batchExchange1.getRowType,
       Array(0),
       Array(1),
-      aggCallToAggFunction,
+      aggCallToAggFunction.toSeq,
       tumblingGroupWindow,
       inputTimeFieldIndex = 2,
       inputTimeIsDate = false,
-      namedPropertiesOfWindowAgg,
+      namedPropertiesOfWindowAgg.asScala.toSeq,
       enableAssignPane = false,
       isMerge = false
     )
@@ -2250,7 +2264,10 @@ class FlinkRelMdHandlerTestBase {
     val rowTypeOfCalc = createRowType("id", "name", "score", "age", "class")
     val rexProgram = RexProgram.create(
       studentFlinkLogicalScan.getRowType,
-      Array(0, 1, 2, 3, 6).map(i => RexInputRef.of(i, studentFlinkLogicalScan.getRowType)).toList,
+      Array(0, 1, 2, 3, 6)
+        .map(i => RexInputRef.of(i, studentFlinkLogicalScan.getRowType))
+        .toList
+        .asJava,
       null,
       rowTypeOfCalc,
       rexBuilder
@@ -2292,20 +2309,23 @@ class FlinkRelMdHandlerTestBase {
       "cnt")
     val projectProgram = RexProgram.create(
       flinkLogicalOverAgg.getRowType,
-      (0 until flinkLogicalOverAgg.getRowType.getFieldCount).flatMap {
-        i =>
-          if (i < 8 || i >= 10) {
-            Array[RexNode](RexInputRef.of(i, flinkLogicalOverAgg.getRowType))
-          } else if (i == 8) {
-            Array[RexNode](
-              rexBuilder.makeCall(
-                SqlStdOperatorTable.DIVIDE,
-                RexInputRef.of(8, flinkLogicalOverAgg.getRowType),
-                RexInputRef.of(9, flinkLogicalOverAgg.getRowType)))
-          } else {
-            Array.empty[RexNode]
-          }
-      }.toList,
+      (0 until flinkLogicalOverAgg.getRowType.getFieldCount)
+        .flatMap {
+          i =>
+            if (i < 8 || i >= 10) {
+              Array[RexNode](RexInputRef.of(i, flinkLogicalOverAgg.getRowType))
+            } else if (i == 8) {
+              Array[RexNode](
+                rexBuilder.makeCall(
+                  SqlStdOperatorTable.DIVIDE,
+                  RexInputRef.of(8, flinkLogicalOverAgg.getRowType),
+                  RexInputRef.of(9, flinkLogicalOverAgg.getRowType)))
+            } else {
+              Array.empty[RexNode]
+            }
+        }
+        .toList
+        .asJava,
       null,
       rowTypeOfWindowAggOutput,
       rexBuilder
@@ -2344,7 +2364,7 @@ class FlinkRelMdHandlerTestBase {
       sort1,
       outputRowType1,
       sort1.getRowType,
-      Seq(overAggGroups(0)),
+      Seq(overAggGroups.get(0)),
       flinkLogicalOverAgg
     )
 
@@ -2376,7 +2396,7 @@ class FlinkRelMdHandlerTestBase {
       sort2,
       outputRowType2,
       sort2.getRowType,
-      Seq(overAggGroups(1)),
+      Seq(overAggGroups.get(1)),
       flinkLogicalOverAgg
     )
 
@@ -2406,7 +2426,7 @@ class FlinkRelMdHandlerTestBase {
       exchange2,
       outputRowType3,
       exchange2.getRowType,
-      Seq(overAggGroups(2)),
+      Seq(overAggGroups.get(2)),
       flinkLogicalOverAgg
     )
 
@@ -2483,7 +2503,10 @@ class FlinkRelMdHandlerTestBase {
     val rowTypeOfCalc = createRowType("id", "name", "score", "age", "class")
     val rexProgram = RexProgram.create(
       studentFlinkLogicalScan.getRowType,
-      Array(0, 1, 2, 3, 6).map(i => RexInputRef.of(i, studentFlinkLogicalScan.getRowType)).toList,
+      Array(0, 1, 2, 3, 6)
+        .map(i => RexInputRef.of(i, studentFlinkLogicalScan.getRowType))
+        .toList
+        .asJava,
       null,
       rowTypeOfCalc,
       rexBuilder
@@ -2527,20 +2550,23 @@ class FlinkRelMdHandlerTestBase {
       createRowType("id", "name", "score", "age", "class", "rk", "drk", "avg_score")
     val projectProgram = RexProgram.create(
       flinkLogicalOverAgg.getRowType,
-      (0 until flinkLogicalOverAgg.getRowType.getFieldCount).flatMap {
-        i =>
-          if (i < 7) {
-            Array[RexNode](RexInputRef.of(i, flinkLogicalOverAgg.getRowType))
-          } else if (i == 7) {
-            Array[RexNode](
-              rexBuilder.makeCall(
-                SqlStdOperatorTable.DIVIDE,
-                RexInputRef.of(7, flinkLogicalOverAgg.getRowType),
-                RexInputRef.of(8, flinkLogicalOverAgg.getRowType)))
-          } else {
-            Array.empty[RexNode]
-          }
-      }.toList,
+      (0 until flinkLogicalOverAgg.getRowType.getFieldCount)
+        .flatMap {
+          i =>
+            if (i < 7) {
+              Array[RexNode](RexInputRef.of(i, flinkLogicalOverAgg.getRowType))
+            } else if (i == 7) {
+              Array[RexNode](
+                rexBuilder.makeCall(
+                  SqlStdOperatorTable.DIVIDE,
+                  RexInputRef.of(7, flinkLogicalOverAgg.getRowType),
+                  RexInputRef.of(8, flinkLogicalOverAgg.getRowType)))
+            } else {
+              Array.empty[RexNode]
+            }
+        }
+        .toList
+        .asJava,
       null,
       rowTypeOfWindowAggOutput,
       rexBuilder
@@ -3284,7 +3310,7 @@ class FlinkRelMdHandlerTestBase {
     relBuilder.push(studentLogicalScan)
 
     if (windowFunctionCall) {
-      val projects = List(
+      val projects = java.util.List.of(
         relBuilder.field(0),
         relBuilder.field(1),
         relBuilder.call(FlinkSqlOperatorTable.PROCTIME))
@@ -3342,7 +3368,10 @@ class FlinkRelMdHandlerTestBase {
             FunctionIdentifier.of("STRING_SPLIT"),
             new JavaUserDefinedTableFunctions.StringSplit())),
         rexBuilder.makeFieldAccess(correlVar, 1),
-        rexBuilder.makeCall(stringType, CAST, List(rexBuilder.makeFieldAccess(correlVar, 0)))
+        rexBuilder.makeCall(
+          stringType,
+          CAST,
+          java.util.List.of[RexNode](rexBuilder.makeFieldAccess(correlVar, 0)))
       )
       new FlinkLogicalTableFunctionScan(
         cluster,
@@ -3421,7 +3450,7 @@ class FlinkRelMdHandlerTestBase {
           ))
       }
     }
-    val program = RexProgram.create(tvf.getRowType, projects, null, outputType, rexBuilder)
+    val program = RexProgram.create(tvf.getRowType, projects.asJava, null, outputType, rexBuilder)
     new StreamPhysicalCalc(
       cluster,
       streamPhysicalTraits,
@@ -3451,7 +3480,12 @@ class FlinkRelMdHandlerTestBase {
   protected def createUnionOnWindowTVF(
       tvf1: CommonPhysicalWindowTableFunction,
       tvf2: CommonPhysicalWindowTableFunction): Union = {
-    new StreamPhysicalUnion(cluster, streamPhysicalTraits, List(tvf1, tvf2), true, tvf1.getRowType)
+    new StreamPhysicalUnion(
+      cluster,
+      streamPhysicalTraits,
+      java.util.List.of(tvf1, tvf2),
+      true,
+      tvf1.getRowType)
   }
 
   // hash by field a
@@ -3487,8 +3521,8 @@ class FlinkRelMdHandlerTestBase {
     relBuilder.push(windowTableFunctionScan)
     val groupKey =
       if (groupByWindow)
-        List(relBuilder.field(0), relBuilder.field(3), relBuilder.field(4))
-      else List(relBuilder.field(0))
+        java.util.List.of(relBuilder.field(0), relBuilder.field(3), relBuilder.field(4))
+      else java.util.List.of[RexInputRef](relBuilder.field(0))
     val logicalAgg =
       relBuilder
         .aggregate(
@@ -3535,7 +3569,7 @@ class FlinkRelMdHandlerTestBase {
       traitSet,
       streamTumbleWindowTVFRel,
       Array(),
-      logicalAgg.getAggCallList,
+      logicalAgg.getAggCallList.asScala.toSeq,
       new WindowAttachedWindowingStrategy(tumbleWindowSpec, timeAttributeType, 5, 6),
       namedWindowProperties)
 
@@ -3656,7 +3690,13 @@ class FlinkRelMdHandlerTestBase {
       upsertKeys: util.Set[ImmutableBitSet],
       statistic: FlinkStatistic = FlinkStatistic.UNKNOWN): T = {
     val intermediateTable =
-      new IntermediateRelTable(Seq(""), relNode, null, false, upsertKeys, statistic)
+      new IntermediateRelTable(
+        java.util.List.of[String](""),
+        relNode,
+        null,
+        false,
+        upsertKeys,
+        statistic)
 
     val conventionTrait = traitSet.getTrait(ConventionTraitDef.INSTANCE)
     val scan = conventionTrait match {
@@ -3722,26 +3762,29 @@ class FlinkRelMdHandlerTestBase {
       literalValues: Seq[String]): util.List[RexLiteral] = {
     require(literalValues.length == rowType.getFieldCount)
     val rexBuilder = relBuilder.getRexBuilder
-    literalValues.zipWithIndex.map {
-      case (v, index) =>
-        val fieldType = rowType.getFieldList.get(index).getType
-        if (v == null) {
-          rexBuilder.makeNullLiteral(fieldType)
-        } else {
-          fieldType.getSqlTypeName match {
-            case BIGINT => rexBuilder.makeLiteral(v.toLong, fieldType, true)
-            case INTEGER => rexBuilder.makeLiteral(v.toInt, fieldType, true)
-            case BOOLEAN => rexBuilder.makeLiteral(v.toBoolean)
-            case DATE => rexBuilder.makeDateLiteral(new DateString(v))
-            case TIME => rexBuilder.makeTimeLiteral(new TimeString(v), 0)
-            case TIMESTAMP => rexBuilder.makeTimestampLiteral(new TimestampString(v), 0)
-            case DOUBLE => rexBuilder.makeApproxLiteral(BigDecimal.valueOf(v.toDouble))
-            case FLOAT => rexBuilder.makeApproxLiteral(BigDecimal.valueOf(v.toFloat))
-            case VARCHAR => rexBuilder.makeLiteral(v)
-            case _ => throw new TableException(s"${fieldType.getSqlTypeName} is not supported!")
-          }
-        }.asInstanceOf[RexLiteral]
-    }.toList
+    literalValues.zipWithIndex
+      .map {
+        case (v, index) =>
+          val fieldType = rowType.getFieldList.get(index).getType
+          if (v == null) {
+            rexBuilder.makeNullLiteral(fieldType)
+          } else {
+            fieldType.getSqlTypeName match {
+              case BIGINT => rexBuilder.makeLiteral(v.toLong, fieldType, true)
+              case INTEGER => rexBuilder.makeLiteral(v.toInt, fieldType, true)
+              case BOOLEAN => rexBuilder.makeLiteral(v.toBoolean)
+              case DATE => rexBuilder.makeDateLiteral(new DateString(v))
+              case TIME => rexBuilder.makeTimeLiteral(new TimeString(v), 0)
+              case TIMESTAMP => rexBuilder.makeTimestampLiteral(new TimestampString(v), 0)
+              case DOUBLE => rexBuilder.makeApproxLiteral(BigDecimal.valueOf(v.toDouble))
+              case FLOAT => rexBuilder.makeApproxLiteral(BigDecimal.valueOf(v.toFloat))
+              case VARCHAR => rexBuilder.makeLiteral(v)
+              case _ => throw new TableException(s"${fieldType.getSqlTypeName} is not supported!")
+            }
+          }.asInstanceOf[RexLiteral]
+      }
+      .toList
+      .asJava
   }
 
   protected def createLogicalCalc(
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicityTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicityTest.scala
index a086c081426ef..586c0daa92c78 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicityTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicityTest.scala
@@ -26,7 +26,7 @@ import org.apache.calcite.rel.RelCollations
 import org.apache.calcite.rel.core.JoinRelType
 import org.apache.calcite.rel.hint.RelHint
 import org.apache.calcite.rel.logical.LogicalCalc
-import org.apache.calcite.rex.{RexNode, RexProgram}
+import org.apache.calcite.rex.{RexInputRef, RexNode, RexProgram}
 import org.apache.calcite.sql.fun.SqlStdOperatorTable._
 import org.apache.calcite.sql.validate.SqlMonotonicity
 import org.apache.calcite.sql.validate.SqlMonotonicity._
@@ -36,7 +36,7 @@ import org.junit.jupiter.api.Test
 
 import java.util
 
-import scala.collection.JavaConversions._
+import scala.collection.JavaConverters.seqAsJavaListConverter
 import scala.language.postfixOps
 
 class FlinkRelMdModifiedMonotonicityTest extends FlinkRelMdHandlerTestBase {
@@ -60,8 +60,9 @@ class FlinkRelMdModifiedMonotonicityTest extends FlinkRelMdHandlerTestBase {
     relBuilder.push(inputAgg)
 
     // project `age` field and corresponding output type
-    val projection = List(relBuilder.field("age"))
-    val ageFieldType = inputAgg.getRowType.getFieldList.filter(x => x.getName.equals("age"))
+    val projection = java.util.List.of[RexInputRef](relBuilder.field("age"))
+    val ageFieldType =
+      inputAgg.getRowType.getFieldList.stream().filter(x => x.getName.equals("age")).toList
     val outputType = new RelRecordType(ageFieldType)
 
     // select age from (select id, age, count() from student by id, age) where ...
@@ -250,7 +251,7 @@ class FlinkRelMdModifiedMonotonicityTest extends FlinkRelMdHandlerTestBase {
       projectWithMaxAgg,
       ImmutableBitSet.of(0),
       null,
-      Seq(tableAggCall)
+      Seq(tableAggCall).toList.asJava
     )
     assertEquals(null, mq.getRelModifiedMonotonicity(tableAggregate))
   }
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdRowCollationTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdRowCollationTest.scala
index 5ee117dc1a42b..c92937cca6f1b 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdRowCollationTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdRowCollationTest.scala
@@ -31,7 +31,7 @@ import org.apache.calcite.util.ImmutableBitSet
 import org.junit.jupiter.api.Assertions.{assertEquals, assertTrue}
 import org.junit.jupiter.api.Test
 
-import scala.collection.JavaConversions._
+import scala.collection.JavaConverters.seqAsJavaListConverter
 
 class FlinkRelMdRowCollationTest extends FlinkRelMdHandlerTestBase {
 
@@ -47,7 +47,7 @@ class FlinkRelMdRowCollationTest extends FlinkRelMdHandlerTestBase {
       List("1", "9.0", "true", "2"),
       List("2", "6.0", "false", "3"),
       List("3", "3.0", "true", "4")
-    ).map(createLiteralList(valuesType, _))
+    ).map(createLiteralList(valuesType, _)).asJava
     relBuilder.clear()
     relBuilder.values(tupleList, valuesType)
     relBuilder.build().asInstanceOf[LogicalValues]
@@ -61,11 +61,20 @@ class FlinkRelMdRowCollationTest extends FlinkRelMdHandlerTestBase {
 
     // Test intermediate table scan.
     val flinkLogicalIntermediateTableScan: FlinkLogicalIntermediateTableScan =
-      createIntermediateScan(flinkLogicalSort, flinkLogicalTraits, Set(ImmutableBitSet.of(0)))
+      createIntermediateScan(
+        flinkLogicalSort,
+        flinkLogicalTraits,
+        java.util.Set.of[ImmutableBitSet](ImmutableBitSet.of(0)))
     val batchPhysicalIntermediateTableScan: BatchPhysicalIntermediateTableScan =
-      createIntermediateScan(batchSort, batchPhysicalTraits, Set(ImmutableBitSet.of(0)))
+      createIntermediateScan(
+        batchSort,
+        batchPhysicalTraits,
+        java.util.Set.of[ImmutableBitSet](ImmutableBitSet.of(0)))
     val streamPhysicalIntermediateTableScan: StreamPhysicalIntermediateTableScan =
-      createIntermediateScan(streamSort, streamPhysicalTraits, Set(ImmutableBitSet.of(0)))
+      createIntermediateScan(
+        streamSort,
+        streamPhysicalTraits,
+        java.util.Set.of[ImmutableBitSet](ImmutableBitSet.of(0)))
     Array(
       flinkLogicalIntermediateTableScan,
       batchPhysicalIntermediateTableScan,
@@ -104,7 +113,7 @@ class FlinkRelMdRowCollationTest extends FlinkRelMdHandlerTestBase {
 
     val project: LogicalProject = {
       relBuilder.push(collationValues)
-      val projects = List(
+      val projects = java.util.List.of(
         // a + b
         relBuilder.call(PLUS, relBuilder.field(0), relBuilder.literal(1)),
         // c
@@ -125,7 +134,8 @@ class FlinkRelMdRowCollationTest extends FlinkRelMdHandlerTestBase {
       .add("a", SqlTypeName.BIGINT)
       .add("ts", SqlTypeName.VARCHAR)
       .build()
-    val tupleList = List(List("3", "2015-07-24 10:00:00")).map(createLiteralList(valuesType, _))
+    val tupleList =
+      List(List("3", "2015-07-24 10:00:00")).map(createLiteralList(valuesType, _)).asJava
     relBuilder.values(tupleList, valuesType)
     val project2 = relBuilder
       .project(
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdRowCountTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdRowCountTest.scala
index 3792805bfff6a..ad44ac902db6f 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdRowCountTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdRowCountTest.scala
@@ -28,8 +28,6 @@ import org.apache.calcite.util.ImmutableBitSet
 import org.junit.jupiter.api.Assertions._
 import org.junit.jupiter.api.Test
 
-import scala.collection.JavaConversions._
-
 class FlinkRelMdRowCountTest extends FlinkRelMdHandlerTestBase {
 
   @Test
@@ -174,7 +172,7 @@ class FlinkRelMdRowCountTest extends FlinkRelMdHandlerTestBase {
         false,
         false,
         false,
-        List[Integer](3),
+        java.util.List.of[Integer](3),
         -1,
         null,
         RelCollations.EMPTY,
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSelectivityTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSelectivityTest.scala
index 1fc2f71faeb13..e8894c4f05f23 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSelectivityTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSelectivityTest.scala
@@ -40,7 +40,7 @@ import org.junit.jupiter.api.Test
 import java.util
 import java.util.Collections
 
-import scala.collection.JavaConversions._
+import scala.collection.JavaConverters.seqAsJavaListConverter
 
 class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
 
@@ -72,9 +72,9 @@ class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
     val expr1 = relBuilder.call(LESS_THAN_OR_EQUAL, relBuilder.field(0), relBuilder.literal(2))
     val expr2 = relBuilder.call(GREATER_THAN, relBuilder.field(0), relBuilder.literal(-1))
     val expr3 = relBuilder.call(LESS_THAN, relBuilder.field(1), relBuilder.literal(1.1d))
-    relBuilder.filter(List(expr1, expr2, expr3))
+    relBuilder.filter(java.util.List.of(expr1, expr2, expr3))
     // top projects: $0==1, $0, $1, true, 2.1, 2
-    val projects = List(
+    val projects = java.util.List.of(
       relBuilder.call(EQUALS, relBuilder.field(0), relBuilder.literal(1)),
       relBuilder.field(0),
       relBuilder.field(1),
@@ -101,7 +101,7 @@ class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
     val expr1 = relBuilder.call(LESS_THAN_OR_EQUAL, relBuilder.field(0), relBuilder.literal(2))
     val expr2 = relBuilder.call(GREATER_THAN, relBuilder.field(0), relBuilder.literal(-1))
     val expr3 = relBuilder.call(LESS_THAN, relBuilder.field(1), relBuilder.literal(1.1d))
-    val filter = relBuilder.filter(List(expr1, expr2, expr3)).build()
+    val filter = relBuilder.filter(java.util.List.of(expr1, expr2, expr3)).build()
     relBuilder.push(filter)
     val pred1 = relBuilder.call(LESS_THAN_OR_EQUAL, relBuilder.field(0), relBuilder.literal(1))
     assertEquals((1.0 + 1.0) / (2.0 + 1.0), mq.getSelectivity(filter, pred1))
@@ -115,7 +115,7 @@ class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
 
     relBuilder.push(ts)
     // projects: $0==1, $0, $1, true, 2.1, 2
-    val projects = List(
+    val projects = java.util.List.of(
       relBuilder.call(EQUALS, relBuilder.field(0), relBuilder.literal(1)),
       relBuilder.field(0),
       relBuilder.field(1),
@@ -132,7 +132,8 @@ class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
     val expr2 = relBuilder.call(GREATER_THAN, relBuilder.field(0), relBuilder.literal(-1))
     val expr3 = relBuilder.call(LESS_THAN, relBuilder.field(1), relBuilder.literal(1.1d))
     val rexBuilder = relBuilder.getRexBuilder
-    val predicate = RexUtil.composeConjunction(rexBuilder, List(expr1, expr2, expr3), true)
+    val predicate =
+      RexUtil.composeConjunction(rexBuilder, java.util.List.of(expr1, expr2, expr3), true)
     val program = RexProgram.create(ts.getRowType, projects, predicate, outputRowType, rexBuilder)
 
     val calc = new BatchPhysicalCalc(cluster, batchPhysicalTraits, ts, program, outputRowType)
@@ -331,14 +332,14 @@ class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
     val aggWithAuxGroupAndExpand = relBuilder
       .push(expand)
       .aggregate(
-        relBuilder.groupKey(relBuilder.fields(Seq[Integer](0, 4).toList)),
+        relBuilder.groupKey(relBuilder.fields(Seq[Integer](0, 4).toList.asJava)),
         Lists.newArrayList(
           AggregateCall.create(
             FlinkSqlOperatorTable.AUXILIARY_GROUP,
             false,
             false,
             false,
-            List[Integer](1),
+            java.util.List.of[Integer](1),
             -1,
             null,
             RelCollations.EMPTY,
@@ -351,7 +352,7 @@ class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
             false,
             false,
             false,
-            List[Integer](2),
+            java.util.List.of[Integer](2),
             -1,
             null,
             RelCollations.EMPTY,
@@ -364,7 +365,7 @@ class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
             false,
             false,
             false,
-            List[Integer](3),
+            java.util.List.of[Integer](3),
             -1,
             null,
             RelCollations.EMPTY,
@@ -544,9 +545,9 @@ class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
         )
       ))
     val scan: FlinkLogicalDataStreamTableScan =
-      createDataStreamScan(List("MyTable4"), flinkLogicalTraits)
+      createDataStreamScan(java.util.List.of[String]("MyTable4"), flinkLogicalTraits)
     val builder = typeFactory.builder
-    scan.getRowType.getFieldList.foreach(f => builder.add(f.getName, f.getType))
+    scan.getRowType.getFieldList.stream().forEach(f => builder.add(f.getName, f.getType))
     builder.add(rankAggCall.getName, rankAggCall.getType)
     builder.add(maxAggCall.getName, maxAggCall.getType)
     val overWindow = new FlinkLogicalOverAggregate(
@@ -607,7 +608,7 @@ class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
     relBuilder.push(ts).push(right)
     val joinCondition = RexUtil.composeConjunction(
       rexBuilder,
-      List(
+      java.util.List.of(
         relBuilder.call(EQUALS, relBuilder.field(2, 0, 0), relBuilder.field(2, 1, 0)),
         relBuilder.call(GREATER_THAN, relBuilder.field(2, 0, 0), relBuilder.literal(-1)),
         relBuilder.call(GREATER_THAN, relBuilder.field(2, 1, 1), relBuilder.literal(0.1d))
@@ -619,7 +620,7 @@ class FlinkRelMdSelectivityTest extends FlinkRelMdHandlerTestBase {
       right,
       Collections.emptyList(),
       joinCondition,
-      Set.empty[CorrelationId],
+      java.util.Set.of[CorrelationId],
       JoinRelType.INNER)
 
     relBuilder.push(join)
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSizeTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSizeTest.scala
index 706ca89348948..738d5c22463cf 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSizeTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdSizeTest.scala
@@ -20,8 +20,6 @@ package org.apache.flink.table.planner.plan.metadata
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
-import scala.collection.JavaConversions._
-
 class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
 
   @Test
@@ -45,47 +43,47 @@ class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
       .foreach {
         scan =>
           assertEquals(
-            Seq(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0),
-            mq.getAverageColumnSizes(scan).toList)
+            java.util.List.of(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0),
+            mq.getAverageColumnSizes(scan))
       }
 
     Array(empLogicalScan, empBatchScan, empStreamScan).foreach {
       scan =>
         assertEquals(
-          Seq(4.0, 12.0, 12.0, 4.0, 12.0, 8.0, 8.0, 4.0),
-          mq.getAverageColumnSizes(scan).toList)
+          java.util.List.of(4.0, 12.0, 12.0, 4.0, 12.0, 8.0, 8.0, 4.0),
+          mq.getAverageColumnSizes(scan))
     }
   }
 
   @Test
   def testAverageColumnSizeOnValues(): Unit = {
     assertEquals(
-      Seq(6.25, 1.0, 9.25, 12.0, 9.25, 8.0, 1.0, 3.75),
-      mq.getAverageColumnSizes(logicalValues).toList)
+      java.util.List.of(6.25, 1.0, 9.25, 12.0, 9.25, 8.0, 1.0, 3.75),
+      mq.getAverageColumnSizes(logicalValues))
     assertEquals(
-      Seq(8.0, 1.0, 12.0, 12.0, 12.0, 8.0, 4.0, 12.0),
-      mq.getAverageColumnSizes(emptyValues).toList)
+      java.util.List.of(8.0, 1.0, 12.0, 12.0, 12.0, 8.0, 4.0, 12.0),
+      mq.getAverageColumnSizes(emptyValues))
   }
 
   @Test
   def testAverageColumnSizeOnProject(): Unit = {
     assertEquals(
-      Seq(8.0, 7.2, 8.0, 4.0, 8.0, 8.0, 8.0, 4.0, 1.0, 8.0, 8.0, 8.0),
-      mq.getAverageColumnSizes(logicalProject).toList)
+      java.util.List.of(8.0, 7.2, 8.0, 4.0, 8.0, 8.0, 8.0, 4.0, 1.0, 8.0, 8.0, 8.0),
+      mq.getAverageColumnSizes(logicalProject))
   }
 
   @Test
   def testAverageColumnSizeOnFilter(): Unit = {
     assertEquals(
-      Seq(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0),
-      mq.getAverageColumnSizes(logicalFilter).toList)
+      java.util.List.of(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0),
+      mq.getAverageColumnSizes(logicalFilter))
   }
 
   @Test
   def testAverageColumnSizeOnCalc(): Unit = {
     assertEquals(
-      Seq(8.0, 7.2, 8.0, 4.0, 8.0, 8.0, 8.0, 4.0, 1.0, 8.0, 8.0, 8.0),
-      mq.getAverageColumnSizes(logicalCalc).toList)
+      java.util.List.of(8.0, 7.2, 8.0, 4.0, 8.0, 8.0, 8.0, 4.0, 1.0, 8.0, 8.0, 8.0),
+      mq.getAverageColumnSizes(logicalCalc))
   }
 
   @Test
@@ -93,8 +91,8 @@ class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
     Array(logicalExpand, flinkLogicalExpand, batchExpand, streamExpand).foreach {
       expand =>
         assertEquals(
-          Seq(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0, 8.0),
-          mq.getAverageColumnSizes(expand).toList)
+          java.util.List.of(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0, 8.0),
+          mq.getAverageColumnSizes(expand))
     }
   }
 
@@ -103,8 +101,8 @@ class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
     Array(batchExchange, streamExchange).foreach {
       exchange =>
         assertEquals(
-          Seq(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0),
-          mq.getAverageColumnSizes(exchange).toList)
+          java.util.List.of(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0),
+          mq.getAverageColumnSizes(exchange))
     }
   }
 
@@ -113,12 +111,12 @@ class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
     Array(logicalRank, flinkLogicalRank, batchGlobalRank, streamRank).foreach {
       rank =>
         assertEquals(
-          Seq(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0, 8.0),
-          mq.getAverageColumnSizes(rank).toList)
+          java.util.List.of(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0, 8.0),
+          mq.getAverageColumnSizes(rank))
     }
     assertEquals(
-      Seq(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0),
-      mq.getAverageColumnSizes(batchLocalRank).toList)
+      java.util.List.of(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0),
+      mq.getAverageColumnSizes(batchLocalRank))
   }
 
   @Test
@@ -140,7 +138,9 @@ class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
       streamLimit
     ).foreach {
       sort =>
-        assertEquals(Seq(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0), mq.getAverageColumnSizes(sort).toList)
+        assertEquals(
+          java.util.List.of(8.0, 7.2, 8.0, 4.0, 8.0, 1.0, 4.0),
+          mq.getAverageColumnSizes(sort))
     }
   }
 
@@ -153,7 +153,8 @@ class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
       batchGlobalAggWithoutLocal,
       streamGlobalAggWithLocal,
       streamGlobalAggWithoutLocal).foreach {
-      agg => assertEquals(Seq(4.0, 8.0, 8.0, 8.0, 8.0, 8.0), mq.getAverageColumnSizes(agg).toList)
+      agg =>
+        assertEquals(java.util.List.of(4.0, 8.0, 8.0, 8.0, 8.0, 8.0), mq.getAverageColumnSizes(agg))
     }
 
     Array(
@@ -161,7 +162,8 @@ class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
       flinkLogicalAggWithAuxGroup,
       batchGlobalAggWithLocalWithAuxGroup,
       batchGlobalAggWithoutLocalWithAuxGroup).foreach {
-      agg => assertEquals(Seq(8.0, 7.2, 8.0, 8.0, 8.0, 8.0), mq.getAverageColumnSizes(agg).toList)
+      agg =>
+        assertEquals(java.util.List.of(8.0, 7.2, 8.0, 8.0, 8.0, 8.0), mq.getAverageColumnSizes(agg))
     }
   }
 
@@ -172,9 +174,14 @@ class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
       flinkLogicalWindowAgg,
       batchGlobalWindowAggWithoutLocalAgg,
       batchGlobalWindowAggWithLocalAgg).foreach {
-      agg => assertEquals(Seq(4d, 32d, 8d, 12d, 12d, 12d, 12d), mq.getAverageColumnSizes(agg).toSeq)
+      agg =>
+        assertEquals(
+          java.util.List.of(4d, 32d, 8d, 12d, 12d, 12d, 12d),
+          mq.getAverageColumnSizes(agg))
     }
-    assertEquals(Seq(4.0, 32.0, 8.0, 8.0), mq.getAverageColumnSizes(batchLocalWindowAgg).toSeq)
+    assertEquals(
+      java.util.List.of(4.0, 32.0, 8.0, 8.0),
+      mq.getAverageColumnSizes(batchLocalWindowAgg))
 
     Array(
       logicalWindowAggWithAuxGroup,
@@ -182,11 +189,14 @@ class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
       batchGlobalWindowAggWithoutLocalAggWithAuxGroup,
       batchGlobalWindowAggWithLocalAggWithAuxGroup
     ).foreach {
-      agg => assertEquals(Seq(8d, 4d, 8d, 12d, 12d, 12d, 12d), mq.getAverageColumnSizes(agg).toSeq)
+      agg =>
+        assertEquals(
+          java.util.List.of(8d, 4d, 8d, 12d, 12d, 12d, 12d),
+          mq.getAverageColumnSizes(agg))
     }
     assertEquals(
-      Seq(8d, 8d, 4d, 8d),
-      mq.getAverageColumnSizes(batchLocalWindowAggWithAuxGroup).toSeq)
+      java.util.List.of(8d, 8d, 4d, 8d),
+      mq.getAverageColumnSizes(batchLocalWindowAggWithAuxGroup))
   }
 
   @Test
@@ -194,19 +204,19 @@ class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
     Array(flinkLogicalOverAgg, batchOverAgg).foreach {
       agg =>
         assertEquals(
-          Seq(8.0, 7.2, 8.0, 4.0, 4.0, 8.0, 8.0, 8.0, 8.0, 8.0, 8.0),
-          mq.getAverageColumnSizes(agg).toList)
+          java.util.List.of(8.0, 7.2, 8.0, 4.0, 4.0, 8.0, 8.0, 8.0, 8.0, 8.0, 8.0),
+          mq.getAverageColumnSizes(agg))
     }
     assertEquals(
-      Seq(8.0, 12.0, 8.0, 4.0, 4.0, 8.0, 8.0, 8.0),
-      mq.getAverageColumnSizes(streamOverAgg).toList)
+      java.util.List.of(8.0, 12.0, 8.0, 4.0, 4.0, 8.0, 8.0, 8.0),
+      mq.getAverageColumnSizes(streamOverAgg))
   }
 
   @Test
   def testAverageColumnSizeOnJoin(): Unit = {
     assertEquals(
-      Seq(4.0, 8.0, 12.0, 88.8, 4.0, 8.0, 8.0, 4.0, 8.0),
-      mq.getAverageColumnSizes(logicalInnerJoinOnUniqueKeys).toList)
+      java.util.List.of(4.0, 8.0, 12.0, 88.8, 4.0, 8.0, 8.0, 4.0, 8.0),
+      mq.getAverageColumnSizes(logicalInnerJoinOnUniqueKeys))
     Array(
       logicalInnerJoinOnDisjointKeys,
       logicalLeftJoinNotOnUniqueKeys,
@@ -214,39 +224,45 @@ class FlinkRelMdSizeTest extends FlinkRelMdHandlerTestBase {
       logicalFullJoinWithoutEquiCond).foreach {
       join =>
         assertEquals(
-          Seq(4.0, 8.0, 12.0, 88.8, 4.0, 4.0, 8.0, 12.0, 10.52, 4.0),
-          mq.getAverageColumnSizes(join).toList)
+          java.util.List.of(4.0, 8.0, 12.0, 88.8, 4.0, 4.0, 8.0, 12.0, 10.52, 4.0),
+          mq.getAverageColumnSizes(join))
     }
 
     Array(logicalSemiJoinOnUniqueKeys, logicalAntiJoinNotOnUniqueKeys).foreach {
-      join => assertEquals(Seq(4.0, 8.0, 12.0, 88.8, 4.0), mq.getAverageColumnSizes(join).toList)
+      join =>
+        assertEquals(java.util.List.of(4.0, 8.0, 12.0, 88.8, 4.0), mq.getAverageColumnSizes(join))
     }
   }
 
   @Test
   def testAverageColumnSizeOnUnion(): Unit = {
     Array(logicalUnion, logicalUnionAll).foreach {
-      union => assertEquals(Seq(4.0, 8.0, 12.0, 49.66, 4.0), mq.getAverageColumnSizes(union).toList)
+      union =>
+        assertEquals(java.util.List.of(4.0, 8.0, 12.0, 49.66, 4.0), mq.getAverageColumnSizes(union))
     }
   }
 
   @Test
   def testAverageColumnSizeOnIntersect(): Unit = {
     Array(logicalIntersect, logicalIntersectAll).foreach {
-      union => assertEquals(Seq(4.0, 8.0, 12.0, 88.8, 4.0), mq.getAverageColumnSizes(union).toList)
+      union =>
+        assertEquals(java.util.List.of(4.0, 8.0, 12.0, 88.8, 4.0), mq.getAverageColumnSizes(union))
     }
   }
 
   @Test
   def testAverageColumnSizeOnMinus(): Unit = {
     Array(logicalMinus, logicalMinusAll).foreach {
-      union => assertEquals(Seq(4.0, 8.0, 12.0, 88.8, 4.0), mq.getAverageColumnSizes(union).toList)
+      union =>
+        assertEquals(java.util.List.of(4.0, 8.0, 12.0, 88.8, 4.0), mq.getAverageColumnSizes(union))
     }
   }
 
   @Test
   def testAverageColumnSizeOnDefault(): Unit = {
-    assertEquals(Seq(8.0, 12.0, 8.0, 4.0, 8.0, 12.0, 4.0), mq.getAverageColumnSizes(testRel).toList)
+    assertEquals(
+      java.util.List.of(8.0, 12.0, 8.0, 4.0, 8.0, 12.0, 4.0),
+      mq.getAverageColumnSizes(testRel))
   }
 
 }
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueGroupsTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueGroupsTest.scala
index 8ae002b351b6a..7f63798a2b8b1 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueGroupsTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueGroupsTest.scala
@@ -21,14 +21,13 @@ import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalExpand
 import org.apache.flink.table.planner.plan.utils.ExpandUtil
 
 import com.google.common.collect.{ImmutableList, ImmutableSet}
+import org.apache.calcite.rex.RexNode
 import org.apache.calcite.sql.fun.SqlStdOperatorTable.{GREATER_THAN, LESS_THAN_OR_EQUAL, MULTIPLY, PLUS}
 import org.apache.calcite.util.ImmutableBitSet
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
-import scala.collection.JavaConversions._
-
 class FlinkRelMdUniqueGroupsTest extends FlinkRelMdHandlerTestBase {
 
   @Test
@@ -86,7 +85,7 @@ class FlinkRelMdUniqueGroupsTest extends FlinkRelMdHandlerTestBase {
     // a <= 2 and b > 10
     val expr1 = relBuilder.call(LESS_THAN_OR_EQUAL, relBuilder.field(0), relBuilder.literal(2))
     val expr2 = relBuilder.call(GREATER_THAN, relBuilder.field(1), relBuilder.literal(10d))
-    val filter1 = relBuilder.filter(List(expr1, expr2)).build()
+    val filter1 = relBuilder.filter(java.util.List.of(expr1, expr2)).build()
     assertEquals(ImmutableBitSet.of(0), mq.getUniqueGroups(filter1, ImmutableBitSet.of(0)))
     assertEquals(ImmutableBitSet.of(0, 1), mq.getUniqueGroups(filter1, ImmutableBitSet.of(0, 1)))
 
@@ -95,7 +94,7 @@ class FlinkRelMdUniqueGroupsTest extends FlinkRelMdHandlerTestBase {
     // a <= 2 and b > 10
     val expr3 = relBuilder.call(LESS_THAN_OR_EQUAL, relBuilder.field(0), relBuilder.literal(2))
     val expr4 = relBuilder.call(GREATER_THAN, relBuilder.field(1), relBuilder.literal(10d))
-    val filter2 = relBuilder.filter(List(expr3, expr4)).build()
+    val filter2 = relBuilder.filter(java.util.List.of(expr3, expr4)).build()
     assertEquals(ImmutableBitSet.of(0), mq.getUniqueGroups(filter2, ImmutableBitSet.of(0)))
     assertEquals(ImmutableBitSet.of(0), mq.getUniqueGroups(filter2, ImmutableBitSet.of(0, 1)))
     assertEquals(ImmutableBitSet.of(0), mq.getUniqueGroups(filter2, ImmutableBitSet.of(0, 1, 2)))
@@ -107,7 +106,7 @@ class FlinkRelMdUniqueGroupsTest extends FlinkRelMdHandlerTestBase {
     relBuilder.scan("MyTable4")
     // a, b, c
     val proj1 = relBuilder
-      .project(List(relBuilder.field(0), relBuilder.field(1), relBuilder.field(2)))
+      .project(java.util.List.of(relBuilder.field(0), relBuilder.field(1), relBuilder.field(2)))
       .build()
     assertEquals(ImmutableBitSet.of(0), mq.getUniqueGroups(proj1, ImmutableBitSet.of(0)))
     assertEquals(ImmutableBitSet.of(0), mq.getUniqueGroups(proj1, ImmutableBitSet.of(0, 1)))
@@ -119,7 +118,7 @@ class FlinkRelMdUniqueGroupsTest extends FlinkRelMdHandlerTestBase {
     // a + b, b * 2, 1
     val proj2 = relBuilder
       .project(
-        List(
+        java.util.List.of(
           relBuilder.call(PLUS, relBuilder.field(0), relBuilder.field(1)),
           relBuilder.call(MULTIPLY, relBuilder.field(1), relBuilder.literal(2)),
           relBuilder.literal(1)
@@ -135,7 +134,7 @@ class FlinkRelMdUniqueGroupsTest extends FlinkRelMdHandlerTestBase {
     // a, b * 2, c, 1, 2
     val proj3 = relBuilder
       .project(
-        List(
+        java.util.List.of(
           relBuilder.field(0),
           relBuilder.call(MULTIPLY, relBuilder.field(1), relBuilder.literal(2)),
           relBuilder.field(2),
@@ -156,8 +155,8 @@ class FlinkRelMdUniqueGroupsTest extends FlinkRelMdHandlerTestBase {
     relBuilder.scan("MyTable4")
     // a, a as a1, $2
     val proj4 = relBuilder
-      .project(
-        List(relBuilder.field(0), relBuilder.alias(relBuilder.field(0), "a1"), relBuilder.field(2)))
+      .project(java.util.List
+        .of(relBuilder.field(0), relBuilder.alias(relBuilder.field(0), "a1"), relBuilder.field(2)))
       .build()
     assertEquals(ImmutableBitSet.of(0), mq.getUniqueGroups(proj4, ImmutableBitSet.of(0)))
     assertEquals(ImmutableBitSet.of(0), mq.getUniqueGroups(proj4, ImmutableBitSet.of(0, 1)))
@@ -167,7 +166,8 @@ class FlinkRelMdUniqueGroupsTest extends FlinkRelMdHandlerTestBase {
     relBuilder.clear()
     relBuilder.scan("MyTable4")
     // true, 1
-    val proj5 = relBuilder.project(List(relBuilder.literal(true), relBuilder.literal(1))).build()
+    val proj5 =
+      relBuilder.project(java.util.List.of(relBuilder.literal(true), relBuilder.literal(1))).build()
     assertEquals(ImmutableBitSet.of(0), mq.getUniqueGroups(proj5, ImmutableBitSet.of(0)))
     assertEquals(ImmutableBitSet.of(1), mq.getUniqueGroups(proj5, ImmutableBitSet.of(1)))
     assertEquals(ImmutableBitSet.of(0), mq.getUniqueGroups(proj5, ImmutableBitSet.of(0, 1)))
@@ -179,7 +179,7 @@ class FlinkRelMdUniqueGroupsTest extends FlinkRelMdHandlerTestBase {
     // project: a, b * 2, c, 1, 2
     // filter: a > 1
     relBuilder.push(ts)
-    val projects = List(
+    val projects = java.util.List.of(
       relBuilder.field(0),
       relBuilder.call(MULTIPLY, relBuilder.field(1), relBuilder.literal(2)),
       relBuilder.field(2),
@@ -188,7 +188,7 @@ class FlinkRelMdUniqueGroupsTest extends FlinkRelMdHandlerTestBase {
     )
     val condition = relBuilder.call(LESS_THAN_OR_EQUAL, relBuilder.field(0), relBuilder.literal(2))
     val outputRowType = relBuilder.push(ts).project(projects).build().getRowType
-    val calc = createLogicalCalc(ts, outputRowType, projects, List(condition))
+    val calc = createLogicalCalc(ts, outputRowType, projects, java.util.List.of[RexNode](condition))
 
     assertEquals(ImmutableBitSet.of(0), mq.getUniqueGroups(calc, ImmutableBitSet.of(0)))
     assertEquals(ImmutableBitSet.of(1), mq.getUniqueGroups(calc, ImmutableBitSet.of(1)))
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeysTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeysTest.scala
index 41fd47cc62a61..38f0c1fe0d45c 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeysTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeysTest.scala
@@ -25,6 +25,7 @@ import org.apache.flink.table.planner.plan.utils.ExpandUtil
 import com.google.common.collect.{ImmutableList, ImmutableSet}
 import org.apache.calcite.prepare.CalciteCatalogReader
 import org.apache.calcite.rel.hint.RelHint
+import org.apache.calcite.rex.RexNode
 import org.apache.calcite.sql.`type`.SqlTypeName.VARCHAR
 import org.apache.calcite.sql.fun.SqlStdOperatorTable.{EQUALS, LESS_THAN}
 import org.apache.calcite.util.ImmutableBitSet
@@ -33,14 +34,14 @@ import org.junit.jupiter.api.Test
 
 import java.util.Collections
 
-import scala.collection.JavaConversions._
+import scala.collection.JavaConverters.setAsJavaSetConverter
 
 class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
 
   @Test
   def testGetUniqueKeysOnTableScan(): Unit = {
     Array(studentLogicalScan, studentBatchScan, studentStreamScan).foreach {
-      scan => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(scan).toSet)
+      scan => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(scan))
     }
 
     Array(empLogicalScan, empBatchScan, empStreamScan).foreach {
@@ -49,21 +50,21 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
 
     val table = relBuilder.getRelOptSchema
       .asInstanceOf[CalciteCatalogReader]
-      .getTable(Seq("projected_table_source_table"))
+      .getTable(java.util.List.of[String]("projected_table_source_table"))
       .asInstanceOf[TableSourceTable]
     val tableSourceScan = new StreamPhysicalTableSourceScan(
       cluster,
       streamPhysicalTraits,
       Collections.emptyList[RelHint](),
       table)
-    assertEquals(uniqueKeys(Array(0, 2)), mq.getUniqueKeys(tableSourceScan).toSet)
+    assertEquals(uniqueKeys(Array(0, 2)), mq.getUniqueKeys(tableSourceScan))
   }
 
   @Test
   def testGetUniqueKeysOnProjectedTableScanWithPartialCompositePrimaryKey(): Unit = {
     val table = relBuilder.getRelOptSchema
       .asInstanceOf[CalciteCatalogReader]
-      .getTable(Seq("projected_table_source_table_with_partial_pk"))
+      .getTable(java.util.List.of[String]("projected_table_source_table_with_partial_pk"))
       .asInstanceOf[TableSourceTable]
     val tableSourceScan = new StreamPhysicalTableSourceScan(
       cluster,
@@ -81,11 +82,11 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
 
   @Test
   def testGetUniqueKeysOnProject(): Unit = {
-    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(logicalProject).toSet)
+    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(logicalProject))
 
     relBuilder.push(studentLogicalScan)
     // id=1, id, cast(id AS bigint not null), cast(id AS int), $1
-    val exprs = List(
+    val exprs = java.util.List.of(
       relBuilder.call(EQUALS, relBuilder.field(0), relBuilder.literal(1)),
       relBuilder.field(0),
       rexBuilder.makeCast(longType, relBuilder.field(0)),
@@ -94,8 +95,8 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
     )
     val project1 = relBuilder.project(exprs).build()
     // INT -> BIGINT is an injective cast, so position 2 is also a unique key
-    assertEquals(uniqueKeys(Array(1), Array(2)), mq.getUniqueKeys(project1).toSet)
-    assertEquals(uniqueKeys(Array(1), Array(2)), mq.getUniqueKeys(project1, true).toSet)
+    assertEquals(uniqueKeys(Array(1), Array(2)), mq.getUniqueKeys(project1))
+    assertEquals(uniqueKeys(Array(1), Array(2)), mq.getUniqueKeys(project1, true))
   }
 
   @Test
@@ -108,14 +109,14 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
 
     // Project: CAST(id AS STRING), name
     // id (position 0 in source) is the unique key
-    val exprs = List(
+    val exprs = java.util.List.of(
       rexBuilder.makeCast(stringType, relBuilder.field(0)), // CAST(id AS STRING)
       relBuilder.field(1) // name
     )
     val project = relBuilder.project(exprs).build()
 
     // The casted id at position 0 should still be recognized as unique
-    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(project).toSet)
+    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(project))
   }
 
   @Test
@@ -127,7 +128,7 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
     val stringType = typeFactory.createSqlType(VARCHAR, 100)
 
     // Project: CAST(id AS STRING), id, name
-    val exprs = List(
+    val exprs = java.util.List.of(
       rexBuilder.makeCast(stringType, relBuilder.field(0)), // CAST(id AS STRING) - injective
       relBuilder.field(0), // id (raw reference)
       relBuilder.field(1) // name
@@ -135,7 +136,7 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
     val project = relBuilder.project(exprs).build()
 
     // Both position 0 (STRING cast of id) and position 1 (raw id) are unique keys
-    assertEquals(uniqueKeys(Array(0), Array(1)), mq.getUniqueKeys(project).toSet)
+    assertEquals(uniqueKeys(Array(0), Array(1)), mq.getUniqueKeys(project))
   }
 
   @Test
@@ -148,7 +149,7 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
 
     // Project: id, CAST(name AS STRING)
     // id is the unique key; name is NOT a key (even after casting)
-    val exprs = List(
+    val exprs = java.util.List.of(
       relBuilder.field(0), // id - the unique key
       rexBuilder.makeCast(stringType, relBuilder.field(1)) // CAST(name AS STRING) - not a key
     )
@@ -156,7 +157,7 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
 
     // Only position 0 (id) is a unique key
     // Position 1 (cast of name) is NOT a key because name wasn't a key to begin with
-    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(project).toSet)
+    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(project))
   }
 
   @Test
@@ -168,39 +169,39 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
     val stringType = typeFactory.createSqlType(VARCHAR, 100)
 
     // First, project id as STRING to simulate a STRING key column
-    val stringKeyExprs = List(
+    val stringKeyExprs = java.util.List.of(
       rexBuilder.makeCast(stringType, relBuilder.field(0)), // CAST(id AS STRING)
       relBuilder.field(1) // name
     )
     val stringKeyProject = relBuilder.project(stringKeyExprs).build()
     // At this point, position 0 is a STRING that's still a unique key
-    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(stringKeyProject).toSet)
+    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(stringKeyProject))
 
     // Now cast the STRING back to INT - this is a non-injective (narrowing) cast
     relBuilder.push(stringKeyProject)
-    val narrowedExprs = List(
+    val narrowedExprs = java.util.List.of(
       rexBuilder.makeCast(intType, relBuilder.field(0)), // CAST(string_id AS INT) - NOT injective
       relBuilder.field(1) // name
     )
     val narrowedProject = relBuilder.project(narrowedExprs).build()
 
     // The key is LOST because STRING->INT is not injective
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(narrowedProject).toSet)
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(narrowedProject))
   }
 
   @Test
   def testGetUniqueKeysOnFilter(): Unit = {
-    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(logicalFilter).toSet)
+    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(logicalFilter))
   }
 
   @Test
   def testGetUniqueKeysOnWatermark(): Unit = {
-    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(logicalWatermarkAssigner).toSet)
+    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(logicalWatermarkAssigner))
   }
 
   @Test
   def testGetUniqueKeysOnMiniBatchAssigner(): Unit = {
-    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(streamMiniBatchAssigner).toSet)
+    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(streamMiniBatchAssigner))
   }
 
   @Test
@@ -212,11 +213,11 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       logicalProject.getRowType,
       logicalProject.getProjects,
-      List(expr))
-    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(logicalCalc).toSet)
+      java.util.List.of[RexNode](expr))
+    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(logicalCalc))
 
     // id=1, id, cast(id AS bigint not null), cast(id AS int), $1
-    val exprs = List(
+    val exprs = java.util.List.of(
       relBuilder.call(EQUALS, relBuilder.field(0), relBuilder.literal(1)),
       relBuilder.field(0),
       rexBuilder.makeCast(longType, relBuilder.field(0)),
@@ -224,16 +225,17 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
       relBuilder.field(1)
     )
     val rowType = relBuilder.project(exprs).build().getRowType
-    val calc2 = createLogicalCalc(studentLogicalScan, rowType, exprs, List(expr))
+    val calc2 =
+      createLogicalCalc(studentLogicalScan, rowType, exprs, java.util.List.of[RexNode](expr))
     // INT -> BIGINT is an injective cast, so position 2 is also a unique key
-    assertEquals(uniqueKeys(Array(1), Array(2)), mq.getUniqueKeys(calc2).toSet)
-    assertEquals(uniqueKeys(Array(1), Array(2)), mq.getUniqueKeys(calc2, true).toSet)
+    assertEquals(uniqueKeys(Array(1), Array(2)), mq.getUniqueKeys(calc2))
+    assertEquals(uniqueKeys(Array(1), Array(2)), mq.getUniqueKeys(calc2, true))
   }
 
   @Test
   def testGetUniqueKeysOnExpand(): Unit = {
     Array(logicalExpand, flinkLogicalExpand, batchExpand, streamExpand).foreach {
-      expand => assertEquals(uniqueKeys(Array(0, 7)), mq.getUniqueKeys(expand).toSet)
+      expand => assertEquals(uniqueKeys(Array(0, 7)), mq.getUniqueKeys(expand))
     }
 
     val expandProjects = ExpandUtil.createExpandProjects(
@@ -259,20 +261,18 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
   @Test
   def testGetUniqueKeysOnExchange(): Unit = {
     Array(batchExchange, streamExchange).foreach {
-      exchange => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(exchange).toSet)
+      exchange => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(exchange))
     }
   }
 
   @Test
   def testGetUniqueKeysOnRank(): Unit = {
     Array(logicalRank, flinkLogicalRank, batchLocalRank, batchGlobalRank, streamRank).foreach {
-      rank => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(rank).toSet)
+      rank => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(rank))
     }
 
     Array(logicalRowNumber, flinkLogicalRowNumber, streamRowNumber)
-      .foreach {
-        rank => assertEquals(uniqueKeys(Array(0), Array(7)), mq.getUniqueKeys(rank).toSet)
-      }
+      .foreach(rank => assertEquals(uniqueKeys(Array(0), Array(7)), mq.getUniqueKeys(rank)))
   }
 
   @Test
@@ -292,25 +292,25 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
       flinkLogicalLimit,
       batchLimit,
       streamLimit
-    ).foreach(sort => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(sort).toSet))
+    ).foreach(sort => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(sort)))
   }
 
   @Test
   def testGetUniqueKeysOnStreamExecDeduplicate(): Unit = {
-    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(streamProcTimeDeduplicateFirstRow).toSet)
-    assertEquals(uniqueKeys(Array(1, 2)), mq.getUniqueKeys(streamProcTimeDeduplicateLastRow).toSet)
-    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(streamRowTimeDeduplicateFirstRow).toSet)
-    assertEquals(uniqueKeys(Array(1, 2)), mq.getUniqueKeys(streamRowTimeDeduplicateLastRow).toSet)
+    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(streamProcTimeDeduplicateFirstRow))
+    assertEquals(uniqueKeys(Array(1, 2)), mq.getUniqueKeys(streamProcTimeDeduplicateLastRow))
+    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(streamRowTimeDeduplicateFirstRow))
+    assertEquals(uniqueKeys(Array(1, 2)), mq.getUniqueKeys(streamRowTimeDeduplicateLastRow))
   }
 
   @Test
   def testGetUniqueKeysOnStreamExecChangelogNormalize(): Unit = {
-    assertEquals(uniqueKeys(Array(1, 0)), mq.getUniqueKeys(streamChangelogNormalize).toSet)
+    assertEquals(uniqueKeys(Array(1, 0)), mq.getUniqueKeys(streamChangelogNormalize))
   }
 
   @Test
   def testGetUniqueKeysOnStreamExecDropUpdateBefore(): Unit = {
-    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(streamDropUpdateBefore).toSet)
+    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(streamDropUpdateBefore))
   }
 
   @Test
@@ -322,7 +322,7 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
       batchGlobalAggWithoutLocal,
       streamGlobalAggWithLocal,
       streamGlobalAggWithoutLocal).foreach {
-      agg => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(agg).toSet)
+      agg => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(agg))
     }
     assertNull(mq.getUniqueKeys(batchLocalAgg))
     assertNull(mq.getUniqueKeys(streamLocalAgg))
@@ -332,7 +332,7 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
       flinkLogicalAggWithAuxGroup,
       batchGlobalAggWithLocalWithAuxGroup,
       batchGlobalAggWithoutLocalWithAuxGroup).foreach {
-      agg => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(agg).toSet)
+      agg => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(agg))
     }
     assertNull(mq.getUniqueKeys(batchLocalAggWithAuxGroup))
   }
@@ -376,93 +376,88 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
   @Test
   def testGetUniqueKeysOnOverAgg(): Unit = {
     Array(flinkLogicalOverAgg, batchOverAgg).foreach {
-      agg => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(agg).toSet)
+      agg => assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(agg))
     }
 
-    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(streamOverAgg).toSet)
+    assertEquals(uniqueKeys(Array(0)), mq.getUniqueKeys(streamOverAgg))
   }
 
   @Test
   def testGetUniqueKeysOnJoin(): Unit = {
     assertEquals(
       uniqueKeys(Array(1), Array(5), Array(1, 5), Array(5, 6), Array(1, 5, 6)),
-      mq.getUniqueKeys(logicalInnerJoinOnUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalInnerJoinNotOnUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalInnerJoinOnRHSUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalInnerJoinWithoutEquiCond).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalInnerJoinWithEquiAndNonEquiCond).toSet)
+      mq.getUniqueKeys(logicalInnerJoinOnUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalInnerJoinNotOnUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalInnerJoinOnRHSUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalInnerJoinWithoutEquiCond))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalInnerJoinWithEquiAndNonEquiCond))
 
     assertEquals(
       uniqueKeys(Array(1), Array(1, 5), Array(1, 5, 6)),
-      mq.getUniqueKeys(logicalLeftJoinOnUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalLeftJoinNotOnUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalLeftJoinOnRHSUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalLeftJoinWithoutEquiCond).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalLeftJoinWithEquiAndNonEquiCond).toSet)
+      mq.getUniqueKeys(logicalLeftJoinOnUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalLeftJoinNotOnUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalLeftJoinOnRHSUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalLeftJoinWithoutEquiCond))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalLeftJoinWithEquiAndNonEquiCond))
 
     assertEquals(
       uniqueKeys(Array(5), Array(1, 5), Array(5, 6), Array(1, 5, 6)),
-      mq.getUniqueKeys(logicalRightJoinOnUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalRightJoinNotOnUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalRightJoinOnLHSUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalRightJoinWithoutEquiCond).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalRightJoinWithEquiAndNonEquiCond).toSet)
+      mq.getUniqueKeys(logicalRightJoinOnUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalRightJoinNotOnUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalRightJoinOnLHSUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalRightJoinWithoutEquiCond))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalRightJoinWithEquiAndNonEquiCond))
 
     assertEquals(
       uniqueKeys(Array(1, 5), Array(1, 5, 6)),
-      mq.getUniqueKeys(logicalFullJoinOnUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalFullJoinNotOnUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalFullJoinOnRHSUniqueKeys).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalFullJoinWithoutEquiCond).toSet)
-    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalFullJoinWithEquiAndNonEquiCond).toSet)
-
-    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalSemiJoinOnUniqueKeys).toSet)
-    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalSemiJoinNotOnUniqueKeys).toSet)
+      mq.getUniqueKeys(logicalFullJoinOnUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalFullJoinNotOnUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalFullJoinOnRHSUniqueKeys))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalFullJoinWithoutEquiCond))
+    assertEquals(uniqueKeys(), mq.getUniqueKeys(logicalFullJoinWithEquiAndNonEquiCond))
+
+    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalSemiJoinOnUniqueKeys))
+    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalSemiJoinNotOnUniqueKeys))
     assertNull(mq.getUniqueKeys(logicalSemiJoinOnRHSUniqueKeys))
-    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalSemiJoinWithoutEquiCond).toSet)
-    assertEquals(
-      uniqueKeys(Array(1)),
-      mq.getUniqueKeys(logicalSemiJoinWithEquiAndNonEquiCond).toSet)
+    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalSemiJoinWithoutEquiCond))
+    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalSemiJoinWithEquiAndNonEquiCond))
 
-    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalAntiJoinOnUniqueKeys).toSet)
-    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalAntiJoinNotOnUniqueKeys).toSet)
+    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalAntiJoinOnUniqueKeys))
+    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalAntiJoinNotOnUniqueKeys))
     assertNull(mq.getUniqueKeys(logicalAntiJoinOnRHSUniqueKeys))
-    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalAntiJoinWithoutEquiCond).toSet)
-    assertEquals(
-      uniqueKeys(Array(1)),
-      mq.getUniqueKeys(logicalAntiJoinWithEquiAndNonEquiCond).toSet)
+    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalAntiJoinWithoutEquiCond))
+    assertEquals(uniqueKeys(Array(1)), mq.getUniqueKeys(logicalAntiJoinWithEquiAndNonEquiCond))
   }
 
   @Test
   def testGetUniqueKeysOnLookupJoin(): Unit = {
     Array(batchLookupJoin, streamLookupJoin).foreach {
-      join => assertEquals(uniqueKeys(), mq.getUniqueKeys(join).toSet)
+      join => assertEquals(uniqueKeys(), mq.getUniqueKeys(join))
     }
   }
 
   @Test
   def testGetUniqueKeysOnLookupJoinWithPk(): Unit = {
     Array(batchLookupJoinWithPk, streamLookupJoinWithPk).foreach {
-      join =>
-        assertEquals(uniqueKeys(Array(7), Array(0, 7), Array(0)), mq.getUniqueKeys(join).toSet)
+      join => assertEquals(uniqueKeys(Array(7), Array(0, 7), Array(0)), mq.getUniqueKeys(join))
     }
   }
 
   @Test
   def testGetUniqueKeysOnLookupJoinNotContainsPk(): Unit = {
     Array(batchLookupJoinNotContainsPk, streamLookupJoinNotContainsPk).foreach {
-      join => assertEquals(uniqueKeys(), mq.getUniqueKeys(join).toSet)
+      join => assertEquals(uniqueKeys(), mq.getUniqueKeys(join))
     }
   }
 
   @Test
   def testGetUniqueKeysOnSetOp(): Unit = {
     Array(logicalUnionAll, logicalIntersectAll, logicalMinusAll).foreach {
-      setOp => assertEquals(uniqueKeys(), mq.getUniqueKeys(setOp).toSet)
+      setOp => assertEquals(uniqueKeys(), mq.getUniqueKeys(setOp))
     }
 
     Array(logicalUnion, logicalIntersect, logicalMinus).foreach {
-      setOp => assertEquals(uniqueKeys(Array(0, 1, 2, 3, 4)), mq.getUniqueKeys(setOp).toSet)
+      setOp => assertEquals(uniqueKeys(Array(0, 1, 2, 3, 4)), mq.getUniqueKeys(setOp))
     }
   }
 
@@ -475,19 +470,19 @@ class FlinkRelMdUniqueKeysTest extends FlinkRelMdHandlerTestBase {
   def testGetUniqueKeysOnTableScanTable(): Unit = {
     assertEquals(
       uniqueKeys(Array(0, 1), Array(0, 1, 5)),
-      mq.getUniqueKeys(logicalLeftJoinOnContainedUniqueKeys).toSet
+      mq.getUniqueKeys(logicalLeftJoinOnContainedUniqueKeys)
     )
     assertEquals(
       uniqueKeys(Array(0, 1, 5)),
-      mq.getUniqueKeys(logicalLeftJoinOnDisjointUniqueKeys).toSet
+      mq.getUniqueKeys(logicalLeftJoinOnDisjointUniqueKeys)
     )
     assertEquals(
       uniqueKeys(),
-      mq.getUniqueKeys(logicalLeftJoinWithNoneKeyTableUniqueKeys).toSet
+      mq.getUniqueKeys(logicalLeftJoinWithNoneKeyTableUniqueKeys)
     )
   }
 
-  private def uniqueKeys(keys: Array[Int]*): Set[ImmutableBitSet] = {
-    keys.map(k => ImmutableBitSet.of(k: _*)).toSet
+  private def uniqueKeys(keys: Array[Int]*): java.util.Set[ImmutableBitSet] = {
+    keys.map(k => ImmutableBitSet.of(k: _*)).toSet.asJava
   }
 }
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUpsertKeysTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUpsertKeysTest.scala
index 4a77662bd2b70..4ae6f389e5182 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUpsertKeysTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUpsertKeysTest.scala
@@ -42,14 +42,14 @@ import org.junit.jupiter.api.Test
 
 import java.util.Collections
 
-import scala.collection.JavaConversions._
+import scala.collection.JavaConverters.setAsJavaSetConverter
 
 class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
 
   @Test
   def testGetUpsertKeysOnTableScan(): Unit = {
     Array(studentLogicalScan, studentBatchScan, studentStreamScan).foreach {
-      scan => assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(scan).toSet)
+      scan => assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(scan))
     }
 
     Array(empLogicalScan, empBatchScan, empStreamScan).foreach {
@@ -58,21 +58,21 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
 
     val table = relBuilder.getRelOptSchema
       .asInstanceOf[CalciteCatalogReader]
-      .getTable(Seq("projected_table_source_table"))
+      .getTable(java.util.List.of[String]("projected_table_source_table"))
       .asInstanceOf[TableSourceTable]
     val tableSourceScan = new StreamPhysicalTableSourceScan(
       cluster,
       streamPhysicalTraits,
       Collections.emptyList[RelHint](),
       table)
-    assertEquals(toBitSet(Array(0, 2)), mq.getUpsertKeys(tableSourceScan).toSet)
+    assertEquals(toBitSet(Array(0, 2)), mq.getUpsertKeys(tableSourceScan))
   }
 
   @Test
   def testGetUpsertKeysOnProjectedTableScanWithPartialCompositePrimaryKey(): Unit = {
     val table = relBuilder.getRelOptSchema
       .asInstanceOf[CalciteCatalogReader]
-      .getTable(Seq("projected_table_source_table_with_partial_pk"))
+      .getTable(java.util.List.of[String]("projected_table_source_table_with_partial_pk"))
       .asInstanceOf[TableSourceTable]
     val tableSourceScan = new StreamPhysicalTableSourceScan(
       cluster,
@@ -90,11 +90,11 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
 
   @Test
   def testGetUpsertKeysOnProject(): Unit = {
-    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(logicalProject).toSet)
+    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(logicalProject))
 
     relBuilder.push(studentLogicalScan)
     // id=1, id, cast(id AS bigint not null), cast(id AS int), $1
-    val exprs = List(
+    val exprs = java.util.List.of(
       relBuilder.call(EQUALS, relBuilder.field(0), relBuilder.literal(1)),
       relBuilder.field(0),
       // INT -> BIGINT is an injective cast, so position 2 is now also an upsert key
@@ -104,7 +104,7 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
     )
     val project1 = relBuilder.project(exprs).build()
 
-    assertEquals(toBitSet(Array(1), Array(2)), mq.getUpsertKeys(project1).toSet)
+    assertEquals(toBitSet(Array(1), Array(2)), mq.getUpsertKeys(project1))
   }
 
   @Test
@@ -116,14 +116,14 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
     val stringType = typeFactory.createSqlType(VARCHAR, 100)
 
     // Project: CAST(id AS STRING), name
-    val exprs = List(
+    val exprs = java.util.List.of(
       rexBuilder.makeCast(stringType, relBuilder.field(0)), // CAST(id AS STRING)
       relBuilder.field(1) // name
     )
     val project = relBuilder.project(exprs).build()
 
     // The casted id at position 0 should still be recognized as upsert key
-    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(project).toSet)
+    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(project))
   }
 
   @Test
@@ -135,7 +135,7 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
     val stringType = typeFactory.createSqlType(VARCHAR, 100)
 
     // Project: CAST(id AS STRING), id, name
-    val exprs = List(
+    val exprs = java.util.List.of(
       rexBuilder.makeCast(stringType, relBuilder.field(0)), // CAST(id AS STRING) - injective
       relBuilder.field(0), // id (raw reference)
       relBuilder.field(1) // name
@@ -143,7 +143,7 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
     val project = relBuilder.project(exprs).build()
 
     // Both position 0 (STRING cast of id) and position 1 (raw id) are upsert keys
-    assertEquals(toBitSet(Array(0), Array(1)), mq.getUpsertKeys(project).toSet)
+    assertEquals(toBitSet(Array(0), Array(1)), mq.getUpsertKeys(project))
   }
 
   @Test
@@ -155,38 +155,38 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
     val stringType = typeFactory.createSqlType(VARCHAR, 100)
 
     // First, project id as STRING to simulate a STRING key column
-    val stringKeyExprs = List(
+    val stringKeyExprs = java.util.List.of(
       rexBuilder.makeCast(stringType, relBuilder.field(0)), // CAST(id AS STRING)
       relBuilder.field(1) // name
     )
     val stringKeyProject = relBuilder.project(stringKeyExprs).build()
-    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(stringKeyProject).toSet)
+    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(stringKeyProject))
 
     // Now cast the STRING back to INT - this is a non-injective cast
     relBuilder.push(stringKeyProject)
-    val narrowedExprs = List(
+    val narrowedExprs = java.util.List.of(
       rexBuilder.makeCast(intType, relBuilder.field(0)), // CAST(string_id AS INT) - NOT injective
       relBuilder.field(1) // name
     )
     val narrowedProject = relBuilder.project(narrowedExprs).build()
 
     // The key is LOST because STRING->INT is not injective
-    assertEquals(toBitSet(), mq.getUpsertKeys(narrowedProject).toSet)
+    assertEquals(toBitSet(), mq.getUpsertKeys(narrowedProject))
   }
 
   @Test
   def testGetUpsertKeysOnFilter(): Unit = {
-    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(logicalFilter).toSet)
+    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(logicalFilter))
   }
 
   @Test
   def testGetUpsertKeysOnWatermark(): Unit = {
-    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(logicalWatermarkAssigner).toSet)
+    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(logicalWatermarkAssigner))
   }
 
   @Test
   def testGetUpsertKeysOnMiniBatchAssigner(): Unit = {
-    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(streamMiniBatchAssigner).toSet)
+    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(streamMiniBatchAssigner))
   }
 
   @Test
@@ -198,11 +198,11 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
       studentLogicalScan,
       logicalProject.getRowType,
       logicalProject.getProjects,
-      List(expr))
-    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(logicalCalc).toSet)
+      java.util.List.of[RexNode](expr))
+    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(logicalCalc))
 
     // id=1, id, cast(id AS bigint not null), cast(id AS int), $1
-    val exprs = List(
+    val exprs = java.util.List.of(
       relBuilder.call(EQUALS, relBuilder.field(0), relBuilder.literal(1)),
       relBuilder.field(0),
       rexBuilder.makeCast(longType, relBuilder.field(0)),
@@ -210,15 +210,16 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
       relBuilder.field(1)
     )
     val rowType = relBuilder.project(exprs).build().getRowType
-    val calc2 = createLogicalCalc(studentLogicalScan, rowType, exprs, List(expr))
+    val calc2 =
+      createLogicalCalc(studentLogicalScan, rowType, exprs, java.util.List.of[RexNode](expr))
     // INT -> BIGINT is an injective cast, so position 2 is now also an upsert key
-    assertEquals(toBitSet(Array(1), Array(2)), mq.getUpsertKeys(calc2).toSet)
+    assertEquals(toBitSet(Array(1), Array(2)), mq.getUpsertKeys(calc2))
   }
 
   @Test
   def testGetUpsertKeysOnExpand(): Unit = {
     Array(logicalExpand, flinkLogicalExpand, batchExpand, streamExpand).foreach {
-      expand => assertEquals(toBitSet(Array(0, 7)), mq.getUpsertKeys(expand).toSet)
+      expand => assertEquals(toBitSet(Array(0, 7)), mq.getUpsertKeys(expand))
     }
 
     val expandProjects = ExpandUtil.createExpandProjects(
@@ -244,18 +245,18 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
   @Test
   def testGetUpsertKeysOnExchange(): Unit = {
     Array(batchExchange, streamExchange).foreach {
-      exchange => assertEquals(toBitSet(), mq.getUpsertKeys(exchange).toSet)
+      exchange => assertEquals(toBitSet(), mq.getUpsertKeys(exchange))
     }
 
     Array(batchExchangeById, streamExchangeById).foreach {
-      exchange => assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(exchange).toSet)
+      exchange => assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(exchange))
     }
   }
 
   @Test
   def testGetUpsertKeysOnRank(): Unit = {
     Array(logicalRank, flinkLogicalRank, batchLocalRank, batchGlobalRank, streamRank).foreach {
-      rank => assertEquals(toBitSet(), mq.getUpsertKeys(rank).toSet)
+      rank => assertEquals(toBitSet(), mq.getUpsertKeys(rank))
     }
 
     Array(
@@ -263,22 +264,20 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
       flinkLogicalRankById,
       batchLocalRankById,
       batchGlobalRankById,
-      streamRankById).foreach {
-      rank => assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(rank).toSet)
-    }
+      streamRankById).foreach(rank => assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(rank)))
 
     Array(logicalRowNumber, flinkLogicalRowNumber, streamRowNumber)
-      .foreach(rank => assertEquals(toBitSet(Array(0), Array(7)), mq.getUpsertKeys(rank).toSet))
+      .foreach(rank => assertEquals(toBitSet(Array(0), Array(7)), mq.getUpsertKeys(rank)))
   }
 
   @Test
   def testGetUpsertKeysOnSort(): Unit = {
     def testWithoutKey(rel: RelNode): Unit = {
-      assertEquals(toBitSet(), mq.getUpsertKeys(rel).toSet)
+      assertEquals(toBitSet(), mq.getUpsertKeys(rel))
     }
 
     def testWithKey(rel: RelNode): Unit = {
-      assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(rel).toSet)
+      assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(rel))
     }
 
     testWithoutKey(logicalSort)
@@ -311,20 +310,20 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
 
   @Test
   def testGetUpsertKeysOnStreamExecDeduplicate(): Unit = {
-    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(streamProcTimeDeduplicateFirstRow).toSet)
-    assertEquals(toBitSet(Array(1, 2)), mq.getUpsertKeys(streamProcTimeDeduplicateLastRow).toSet)
-    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(streamRowTimeDeduplicateFirstRow).toSet)
-    assertEquals(toBitSet(Array(1, 2)), mq.getUpsertKeys(streamRowTimeDeduplicateLastRow).toSet)
+    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(streamProcTimeDeduplicateFirstRow))
+    assertEquals(toBitSet(Array(1, 2)), mq.getUpsertKeys(streamProcTimeDeduplicateLastRow))
+    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(streamRowTimeDeduplicateFirstRow))
+    assertEquals(toBitSet(Array(1, 2)), mq.getUpsertKeys(streamRowTimeDeduplicateLastRow))
   }
 
   @Test
   def testGetUpsertKeysOnStreamExecChangelogNormalize(): Unit = {
-    assertEquals(toBitSet(Array(1, 0)), mq.getUpsertKeys(streamChangelogNormalize).toSet)
+    assertEquals(toBitSet(Array(1, 0)), mq.getUpsertKeys(streamChangelogNormalize))
   }
 
   @Test
   def testGetUpsertKeysOnStreamExecDropUpdateBefore(): Unit = {
-    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(streamDropUpdateBefore).toSet)
+    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(streamDropUpdateBefore))
   }
 
   @Test
@@ -336,7 +335,7 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
       batchGlobalAggWithoutLocal,
       streamGlobalAggWithLocal,
       streamGlobalAggWithoutLocal).foreach {
-      agg => assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(agg).toSet)
+      agg => assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(agg))
     }
     assertNull(mq.getUpsertKeys(batchLocalAgg))
     assertNull(mq.getUpsertKeys(streamLocalAgg))
@@ -346,7 +345,7 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
       flinkLogicalAggWithAuxGroup,
       batchGlobalAggWithLocalWithAuxGroup,
       batchGlobalAggWithoutLocalWithAuxGroup).foreach {
-      agg => assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(agg).toSet)
+      agg => assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(agg))
     }
     assertNull(mq.getUpsertKeys(batchLocalAggWithAuxGroup))
   }
@@ -390,88 +389,88 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
   @Test
   def testGetUpsertKeysOnOverAgg(): Unit = {
     Array(flinkLogicalOverAgg, batchOverAgg, streamOverAgg).foreach {
-      agg => assertEquals(toBitSet(), mq.getUpsertKeys(agg).toSet)
+      agg => assertEquals(toBitSet(), mq.getUpsertKeys(agg))
     }
 
-    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(streamOverAggById).toSet)
+    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(streamOverAggById))
   }
 
   @Test
   def testGetUpsertKeysOnJoin(): Unit = {
     assertEquals(
       toBitSet(Array(1), Array(5), Array(1, 5), Array(5, 6), Array(1, 5, 6)),
-      mq.getUpsertKeys(logicalInnerJoinOnUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalInnerJoinNotOnUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalInnerJoinOnRHSUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalInnerJoinWithoutEquiCond).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalInnerJoinWithEquiAndNonEquiCond).toSet)
+      mq.getUpsertKeys(logicalInnerJoinOnUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalInnerJoinNotOnUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalInnerJoinOnRHSUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalInnerJoinWithoutEquiCond))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalInnerJoinWithEquiAndNonEquiCond))
 
     assertEquals(
       toBitSet(Array(1), Array(1, 5), Array(1, 5, 6)),
-      mq.getUpsertKeys(logicalLeftJoinOnUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalLeftJoinNotOnUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalLeftJoinOnRHSUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalLeftJoinWithoutEquiCond).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalLeftJoinWithEquiAndNonEquiCond).toSet)
+      mq.getUpsertKeys(logicalLeftJoinOnUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalLeftJoinNotOnUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalLeftJoinOnRHSUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalLeftJoinWithoutEquiCond))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalLeftJoinWithEquiAndNonEquiCond))
 
     assertEquals(
       toBitSet(Array(5), Array(1, 5), Array(5, 6), Array(1, 5, 6)),
-      mq.getUpsertKeys(logicalRightJoinOnUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalRightJoinNotOnUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalRightJoinOnLHSUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalRightJoinWithoutEquiCond).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalRightJoinWithEquiAndNonEquiCond).toSet)
+      mq.getUpsertKeys(logicalRightJoinOnUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalRightJoinNotOnUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalRightJoinOnLHSUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalRightJoinWithoutEquiCond))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalRightJoinWithEquiAndNonEquiCond))
 
     assertEquals(
       toBitSet(Array(1, 5), Array(1, 5, 6)),
-      mq.getUpsertKeys(logicalFullJoinOnUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalFullJoinNotOnUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalFullJoinOnRHSUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalFullJoinWithoutEquiCond).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalFullJoinWithEquiAndNonEquiCond).toSet)
-
-    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(logicalSemiJoinOnUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalSemiJoinNotOnUniqueKeys).toSet)
+      mq.getUpsertKeys(logicalFullJoinOnUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalFullJoinNotOnUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalFullJoinOnRHSUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalFullJoinWithoutEquiCond))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalFullJoinWithEquiAndNonEquiCond))
+
+    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(logicalSemiJoinOnUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalSemiJoinNotOnUniqueKeys))
     assertNull(mq.getUpsertKeys(logicalSemiJoinOnRHSUniqueKeys))
-    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(logicalSemiJoinWithoutEquiCond).toSet)
-    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(logicalSemiJoinWithEquiAndNonEquiCond).toSet)
+    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(logicalSemiJoinWithoutEquiCond))
+    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(logicalSemiJoinWithEquiAndNonEquiCond))
 
-    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(logicalAntiJoinOnUniqueKeys).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalAntiJoinNotOnUniqueKeys).toSet)
+    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(logicalAntiJoinOnUniqueKeys))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalAntiJoinNotOnUniqueKeys))
     assertNull(mq.getUpsertKeys(logicalAntiJoinOnRHSUniqueKeys))
-    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(logicalAntiJoinWithoutEquiCond).toSet)
-    assertEquals(toBitSet(), mq.getUpsertKeys(logicalAntiJoinWithEquiAndNonEquiCond).toSet)
+    assertEquals(toBitSet(Array(1)), mq.getUpsertKeys(logicalAntiJoinWithoutEquiCond))
+    assertEquals(toBitSet(), mq.getUpsertKeys(logicalAntiJoinWithEquiAndNonEquiCond))
   }
 
   @Test
   def testGetUpsertKeysOnLookupJoin(): Unit = {
     Array(batchLookupJoin, streamLookupJoin).foreach {
-      join => assertEquals(toBitSet(), mq.getUpsertKeys(join).toSet)
+      join => assertEquals(toBitSet(), mq.getUpsertKeys(join))
     }
   }
 
   @Test
   def testGetUpsertKeysOnLookupJoinWithPk(): Unit = {
     Array(batchLookupJoinWithPk, streamLookupJoinWithPk).foreach {
-      join => assertEquals(toBitSet(Array(7), Array(0, 7), Array(0)), mq.getUpsertKeys(join).toSet)
+      join => assertEquals(toBitSet(Array(7), Array(0, 7), Array(0)), mq.getUpsertKeys(join))
     }
   }
 
   @Test
   def testGetUpsertKeysOnLookupJoinNotContainsPk(): Unit = {
     Array(batchLookupJoinNotContainsPk, streamLookupJoinNotContainsPk).foreach {
-      join => assertEquals(toBitSet(), mq.getUpsertKeys(join).toSet)
+      join => assertEquals(toBitSet(), mq.getUpsertKeys(join))
     }
   }
 
   @Test
   def testGetUpsertKeysOnSetOp(): Unit = {
     Array(logicalUnionAll, logicalIntersectAll, logicalMinusAll).foreach {
-      setOp => assertEquals(toBitSet(), mq.getUpsertKeys(setOp).toSet)
+      setOp => assertEquals(toBitSet(), mq.getUpsertKeys(setOp))
     }
 
     Array(logicalUnion, logicalIntersect, logicalMinus).foreach {
-      setOp => assertEquals(toBitSet(Array(0, 1, 2, 3, 4)), mq.getUpsertKeys(setOp).toSet)
+      setOp => assertEquals(toBitSet(Array(0, 1, 2, 3, 4)), mq.getUpsertKeys(setOp))
     }
   }
 
@@ -482,7 +481,7 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
 
   @Test
   def testGetUpsertKeysOnIntermediateScan(): Unit = {
-    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(intermediateScan).toSet)
+    assertEquals(toBitSet(Array(0)), mq.getUpsertKeys(intermediateScan))
   }
 
   @Test
@@ -490,7 +489,7 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
     // Immutable columns: {0, 1, 2} (PK 'a' + immutable 'c', 'd')
     assertEquals(
       toBitSet(Array(0), Array(0, 1, 2)),
-      mq.getUpsertKeys(tableWithImmutableColsLogicalScan).toSet)
+      mq.getUpsertKeys(tableWithImmutableColsLogicalScan))
   }
 
   @Test
@@ -502,7 +501,7 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
       streamPhysicalTraits.replace(hash1),
       tableWithImmutableColsStreamScan,
       hash1)
-    assertEquals(toBitSet(Array(0), Array(0, 1, 2)), mq.getUpsertKeys(exchange1).toSet)
+    assertEquals(toBitSet(Array(0), Array(0, 1, 2)), mq.getUpsertKeys(exchange1))
 
     // Hash exchange on column 3 (rowtime, NOT immutable)
     val hash3 = FlinkRelDistribution.hash(Array(3), requireStrict = true)
@@ -511,7 +510,7 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
       streamPhysicalTraits.replace(hash3),
       tableWithImmutableColsStreamScan,
       hash3)
-    assertEquals(toBitSet(), mq.getUpsertKeys(exchange3).toSet)
+    assertEquals(toBitSet(), mq.getUpsertKeys(exchange3))
   }
 
   @Test
@@ -519,12 +518,12 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
     // Sort on column 1 (c, immutable)
     relBuilder.push(tableWithImmutableColsLogicalScan)
     val sort1 = relBuilder.sort(relBuilder.field(1)).build()
-    assertEquals(toBitSet(Array(0), Array(0, 1, 2)), mq.getUpsertKeys(sort1).toSet)
+    assertEquals(toBitSet(Array(0), Array(0, 1, 2)), mq.getUpsertKeys(sort1))
 
     // Sort on column 3 (rowtime, NOT immutable)
     relBuilder.push(tableWithImmutableColsLogicalScan)
     val sort3 = relBuilder.sort(relBuilder.field(3)).build()
-    assertEquals(toBitSet(), mq.getUpsertKeys(sort3).toSet)
+    assertEquals(toBitSet(), mq.getUpsertKeys(sort3))
   }
 
   @Test
@@ -553,11 +552,11 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
 
     // Rank partitioned by column 1 (c, immutable)
     val rank1 = buildRank(1)
-    assertEquals(toBitSet(Array(0), Array(0, 1, 2)), mq.getUpsertKeys(rank1).toSet)
+    assertEquals(toBitSet(Array(0), Array(0, 1, 2)), mq.getUpsertKeys(rank1))
 
     // Rank partitioned by column 3 (rowtime, NOT immutable)
     val rank3 = buildRank(3)
-    assertEquals(toBitSet(), mq.getUpsertKeys(rank3).toSet)
+    assertEquals(toBitSet(), mq.getUpsertKeys(rank3))
   }
 
   @Test
@@ -621,11 +620,11 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
 
     // Over agg partitioned by column 1 (c, immutable)
     val over1 = buildOverAgg(1)
-    assertEquals(toBitSet(Array(0), Array(0, 1, 2)), mq.getUpsertKeys(over1).toSet)
+    assertEquals(toBitSet(Array(0), Array(0, 1, 2)), mq.getUpsertKeys(over1))
 
     // Over agg partitioned by column 3 (rowtime, NOT immutable)
     val over3 = buildOverAgg(3)
-    assertEquals(toBitSet(), mq.getUpsertKeys(over3).toSet)
+    assertEquals(toBitSet(), mq.getUpsertKeys(over3))
   }
 
   @Test
@@ -639,7 +638,7 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
         JoinRelType.SEMI,
         relBuilder.call(EQUALS, relBuilder.field(2, 0, 1), relBuilder.field(2, 1, 1)))
       .build()
-    assertEquals(toBitSet(Array(0), Array(0, 1, 2)), mq.getUpsertKeys(join1).toSet)
+    assertEquals(toBitSet(Array(0), Array(0, 1, 2)), mq.getUpsertKeys(join1))
   }
 
   @Test
@@ -659,10 +658,10 @@ class FlinkRelMdUpsertKeysTest extends FlinkRelMdHandlerTestBase {
       .build()
     assertEquals(
       toBitSet(Array(0, 4), Array(0, 4, 5, 6), Array(0, 1, 2, 4), Array(0, 1, 2, 4, 5, 6)),
-      mq.getUpsertKeys(join).toSet)
+      mq.getUpsertKeys(join))
   }
 
-  private def toBitSet(keys: Array[Int]*): Set[ImmutableBitSet] = {
-    keys.map(k => ImmutableBitSet.of(k: _*)).toSet
+  private def toBitSet(keys: Array[Int]*): java.util.Set[ImmutableBitSet] = {
+    keys.map(k => ImmutableBitSet.of(k: _*)).toSet.asJava
   }
 }

From 9e4cd0c593404e5ce0e08e84e5b25231306f7975 Mon Sep 17 00:00:00 2001
From: Sergey Nuyanzin <snuyanzin@gmail.com>
Date: Thu, 28 May 2026 15:54:22 +0200
Subject: [PATCH 3/5] [FLINK-39817][table] Upgrade Calcite to 1.39.0

---
 flink-table/flink-sql-parser/pom.xml          |    8 +-
 .../src/main/codegen/data/Parser.tdd          |    4 +
 .../src/main/codegen/templates/Parser.jj      |  102 +-
 .../calcite/sql/type/SqlTypeFamily.java       |  292 --
 .../apache/calcite/sql/type/SqlTypeName.java  | 1078 ----
 .../parser/validate/FlinkSqlConformance.java  |   15 +
 .../flink-table-calcite-bridge/pom.xml        |    8 +-
 .../calcite/jdbc/SimpleCalciteSchema.java     |   56 +-
 .../org/apache/calcite/plan/RelOptUtil.java   | 4596 -----------------
 .../calcite/rel/rules/SubQueryRemoveRule.java |  115 +-
 .../rel/type/RelDataTypeFactoryImpl.java      |   14 +-
 .../org/apache/calcite/rex/RexBuilder.java    | 2206 --------
 .../org/apache/calcite/rex/RexChecker.java    |  203 -
 .../apache/calcite/rex/RexFieldAccess.java    |  141 -
 .../org/apache/calcite/rex/RexProgram.java    |  984 ----
 .../org/apache/calcite/rex/RexShuttle.java    |  284 -
 .../java/org/apache/calcite/rex/RexUtil.java  |   18 +-
 .../apache/calcite/runtime/SqlFunctions.java  |  384 +-
 .../java/org/apache/calcite/sql/SqlUtil.java  |    6 +-
 .../apache/calcite/sql/type/BasicSqlType.java |    2 +-
 .../sql/type/SqlTypeAssignmentRule.java       |    4 +-
 .../calcite/sql/type/SqlTypeFactoryImpl.java  |   64 +-
 .../apache/calcite/sql/type/SqlTypeUtil.java  |   86 +-
 .../sql/validate/SqlValidatorImpl.java        |  408 +-
 .../apache/calcite/sql2rel/AggConverter.java  |    2 +-
 .../calcite/sql2rel/RelDecorrelator.java      |  486 +-
 .../calcite/sql2rel/SqlToRelConverter.java    |  492 +-
 .../calcite/FlinkCalciteSqlValidator.java     |   11 +
 .../src/main/resources/META-INF/NOTICE        |    6 +-
 .../planner/plan/utils/TemporalJoinUtil.scala |    3 -
 .../planner/functions/CastFunctionITCase.java |    3 +-
 .../table/planner/plan/batch/sql/CalcTest.xml |    2 +-
 .../plan/batch/sql/DeadlockBreakupTest.xml    |    2 +-
 .../batch/sql/DynamicFunctionPlanTest.xml     |    9 +-
 .../plan/batch/sql/SetOperatorsTest.xml       |    4 +-
 .../ReplaceIntersectWithSemiJoinRuleTest.xml  |    2 +-
 .../ReplaceMinusWithAntiJoinRuleTest.xml      |    2 +-
 .../logical/WindowGroupReorderRuleTest.xml    |    2 +-
 .../logical/subquery/SubQueryAntiJoinTest.xml |  180 +
 .../logical/subquery/SubQuerySemiJoinTest.xml |  109 +
 ...PushCalcPastChangelogNormalizeRuleTest.xml |   18 +-
 .../planner/plan/stream/sql/CalcTest.xml      |    2 +-
 .../plan/stream/sql/SetOperatorsTest.xml      |    4 +-
 .../planner/plan/stream/table/ValuesTest.xml  |    2 +-
 .../expressions/SqlExpressionTest.scala       |    3 +-
 .../subquery/SubQueryAntiJoinTest.scala       |   16 +-
 .../subquery/SubQuerySemiJoinTest.scala       |   12 +-
 flink-table/pom.xml                           |    2 +-
 48 files changed, 1879 insertions(+), 10573 deletions(-)
 delete mode 100644 flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java
 delete mode 100644 flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
 delete mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/plan/RelOptUtil.java
 delete mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexBuilder.java
 delete mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexChecker.java
 delete mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexFieldAccess.java
 delete mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexProgram.java
 delete mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexShuttle.java

diff --git a/flink-table/flink-sql-parser/pom.xml b/flink-table/flink-sql-parser/pom.xml
index 0264583bfecc7..8be0c191ffb04 100644
--- a/flink-table/flink-sql-parser/pom.xml
+++ b/flink-table/flink-sql-parser/pom.xml
@@ -68,11 +68,11 @@ under the License.
 			<version>${calcite.version}</version>
 			<exclusions>
 				<!--
-				"mvn dependency:tree" as of Calcite 1.38.0:
+				"mvn dependency:tree" as of Calcite 1.39.0:
 
-				[INFO] +- org.apache.calcite:calcite-core:jar:1.38.0:compile
-				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.38.0:compile
-				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.25.0:compile
+				[INFO] +- org.apache.calcite:calcite-core:jar:1.39.0:compile
+				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.39.0:compile
+				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.26.0:compile
 				[INFO] |  +- org.apiguardian:apiguardian-api:jar:1.1.2:compile
 				[INFO] |  +- org.checkerframework:checker-qual:jar:3.43.0:compile
 				[INFO] |  \- org.apache.commons:commons-math3:jar:3.6.1:runtime
diff --git a/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd b/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd
index 74339361d7939..84b69813a5247 100644
--- a/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd
+++ b/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd
@@ -633,6 +633,7 @@
     "OVERWRITING"
     "PARTITIONED"
     "PARTITIONS"
+    "UUID"
     "VIRTUAL"
     "ANALYZE"
     "COMPUTE"
@@ -772,6 +773,9 @@
   joinTypes: [
   ]
 
+  # Method for parsing "SET [OR RESET]" calls.
+  setOptionParserMethod: "SqlSetOption"
+
   includePosixOperators: false
   includeCompoundIdentifier: true
   includeBraces: true
diff --git a/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj b/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
index 0c6671b132a4b..a129d40bafda5 100644
--- a/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
+++ b/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
@@ -1145,7 +1145,7 @@ SqlNode SqlStmt() :
         LOOKAHEAD(2) stmt = ${method}
     |
 </#list>
-        stmt = SqlSetOption(Span.of(), null)
+        stmt = ${parser.setOptionParserMethod!default.parser.setOptionParserMethod}(Span.of(), null)
     |
         stmt = SqlAlter()
     |
@@ -4384,7 +4384,7 @@ SqlSetOption SqlSetOption(Span s, String scope) :
             }
         )
         {
-            return new SqlSetOption(s.end(val), scope, name, val);
+            return new SqlSetOption(s.end(val), scope, (SqlNode) name, val);
         }
     |
         <RESET> {
@@ -4399,7 +4399,7 @@ SqlSetOption SqlSetOption(Span s, String scope) :
             }
         )
         {
-            return new SqlSetOption(s.end(name), scope, name, null);
+            return new SqlSetOption(s.end(name), scope, (SqlNode) name, null);
         }
     )
 }
@@ -4423,8 +4423,7 @@ SqlAlter SqlAlter() :
         alterNode = ${method}(s, scope)
     |
 </#list>
-
-        alterNode = SqlSetOption(s, scope)
+        alterNode = ${parser.setOptionParserMethod!default.parser.setOptionParserMethod}(s, scope)
     )
     {
         return alterNode;
@@ -4877,6 +4876,11 @@ SqlLiteral DateTimeLiteral() :
     <TIME> { s = span(); } p = SimpleStringLiteral() {
       return SqlLiteral.createUnknown("TIME", p, s.end(this));
     }
+|
+    LOOKAHEAD(2)
+    <UUID> { s = span(); } p = SimpleStringLiteral() {
+        return SqlLiteral.createUnknown("UUID", p, s.end(this));
+    }
 |
     LOOKAHEAD(2)
     <TIMESTAMP> { s = span(); } p = SimpleStringLiteral() {
@@ -5913,6 +5917,8 @@ SqlTypeNameSpec SqlTypeName1(Span s) :
         <FLOAT> { s.add(this); sqlTypeName = SqlTypeName.FLOAT; }
     |
         <VARIANT> { s.add(this); sqlTypeName = SqlTypeName.VARIANT; }
+    |
+        <UUID> { s.add(this); sqlTypeName = SqlTypeName.UUID; }
     )
     {
         return new SqlBasicTypeNameSpec(sqlTypeName, s.end(this));
@@ -6334,10 +6340,17 @@ SqlNode BuiltinFunctionCall() :
                 }
             |
                 <COMMA> e = SimpleIdentifier() { args.add(e); }
-                <COMMA> e = SimpleIdentifier() { args.add(e); }
-                <RPAREN> {
-                    return SqlStdOperatorTable.CONVERT.createCall(s.end(this), args);
-                }
+                (
+                    <COMMA> e = SimpleIdentifier() { args.add(e); }
+                    <RPAREN> {
+                        SqlOperator op = SqlStdOperatorTable.getConvertFuncByConformance(this.conformance);
+                        return op.createCall(s.end(this), args);
+                    }
+                |
+                    <RPAREN> {
+                        return SqlLibraryOperators.CONVERT_ORACLE.createCall(s.end(this), args);
+                    }
+                )
             )
         |
             // MSSql CONVERT(type, val [,style])
@@ -6414,59 +6427,49 @@ SqlNode BuiltinFunctionCall() :
         <TRIM> {
             SqlLiteral flag = null;
             SqlNode trimChars = null;
+            SqlParserPos fromPos = SqlParserPos.ZERO;
             s = span();
         }
         <LPAREN>
-        [
-            LOOKAHEAD(2)
-            [
-                <BOTH> {
-                    s.add(this);
-                    flag = SqlTrimFunction.Flag.BOTH.symbol(getPos());
-                }
-            |
-                <TRAILING> {
-                    s.add(this);
-                    flag = SqlTrimFunction.Flag.TRAILING.symbol(getPos());
-                }
-            |
-                <LEADING> {
-                    s.add(this);
-                    flag = SqlTrimFunction.Flag.LEADING.symbol(getPos());
-                }
-            ]
-            [ trimChars = Expression(ExprContext.ACCEPT_SUB_QUERY) ]
+        (
             (
-                <FROM> {
-                    if (null == flag && null == trimChars) {
-                        throw SqlUtil.newContextException(getPos(),
-                            RESOURCE.illegalFromEmpty());
+                (
+                    <BOTH> {
+                        s.add(this);
+                        flag = SqlTrimFunction.Flag.BOTH.symbol(getPos());
                     }
-                }
-            |
-                <RPAREN> {
-                    // This is to handle the case of TRIM(x)
-                    // (FRG-191).
-                    if (flag == null) {
-                        flag = SqlTrimFunction.Flag.BOTH.symbol(SqlParserPos.ZERO);
+                |
+                    <TRAILING> {
+                        s.add(this);
+                        flag = SqlTrimFunction.Flag.TRAILING.symbol(getPos());
                     }
-                    args.add(flag);
-                    args.add(null); // no trim chars
-                    args.add(trimChars); // reinterpret trimChars as source
-                    return SqlStdOperatorTable.TRIM.createCall(s.end(this),
-                        args);
-                }
+                |
+                    <LEADING> {
+                        s.add(this);
+                        flag = SqlTrimFunction.Flag.LEADING.symbol(getPos());
+                    }
+                )
+                [ trimChars = Expression(ExprContext.ACCEPT_SUB_QUERY) ]
+                <FROM> { fromPos = getPos(); }
+                e = Expression(ExprContext.ACCEPT_SUB_QUERY)
             )
-        ]
-        e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
+            |
+            (
+                e = Expression(ExprContext.ACCEPT_SUB_QUERY)
+                [
+                    <FROM> { trimChars = e; fromPos = getPos(); }
+                    e = Expression(ExprContext.ACCEPT_SUB_QUERY)
+                ]
+            )
+        )
+        <RPAREN> {
             if (flag == null) {
                 flag = SqlTrimFunction.Flag.BOTH.symbol(SqlParserPos.ZERO);
             }
             args.add(flag);
+            // trimChars can be null
             args.add(trimChars);
             args.add(e);
-        }
-        <RPAREN> {
             return SqlStdOperatorTable.TRIM.createCall(s.end(this), args);
         }
     |
@@ -8721,6 +8724,7 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < UTF8: "UTF8" >
 |   < UTF16: "UTF16" >
 |   < UTF32: "UTF32" >
+|   < UUID: "UUID" >
 |   < VALUE: "VALUE" >
 |   < VALUES: "VALUES" > { afterTableName(); }
 |   < VALUE_OF: "VALUE_OF" >
diff --git a/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java b/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java
deleted file mode 100644
index b755fc4d6f46f..0000000000000
--- a/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java
+++ /dev/null
@@ -1,292 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.sql.type;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import org.apache.calcite.avatica.util.TimeUnit;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.calcite.rel.type.RelDataTypeFamily;
-import org.apache.calcite.sql.SqlIntervalQualifier;
-import org.apache.calcite.sql.SqlWindow;
-import org.apache.calcite.sql.parser.SqlParserPos;
-import org.checkerframework.checker.nullness.qual.Nullable;
-
-import java.sql.Types;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
-/**
- * SqlTypeFamily provides SQL type categorization.
- *
- * <p>The <em>primary</em> family categorization is a complete disjoint partitioning of SQL types
- * into families, where two types are members of the same primary family iff instances of the two
- * types can be the operands of an SQL equality predicate such as <code>WHERE v1 = v2</code>.
- * Primary families are returned by RelDataType.getFamily().
- *
- * <p>There is also a <em>secondary</em> family categorization which overlaps with the primary
- * categorization. It is used in type strategies for more specific or more general categorization
- * than the primary families. Secondary families are never returned by RelDataType.getFamily().
- *
- * <p>This class was copied over from Calcite to support variant type(CALCITE-4918). When upgrading
- * to Calcite 1.39.0 version, please remove the entire class.
- */
-public enum SqlTypeFamily implements RelDataTypeFamily {
-    // Primary families.
-    CHARACTER,
-    BINARY,
-    NUMERIC,
-    DATE,
-    TIME,
-    TIMESTAMP,
-    BOOLEAN,
-    INTERVAL_YEAR_MONTH,
-    INTERVAL_DAY_TIME,
-
-    // Secondary families.
-
-    STRING,
-    APPROXIMATE_NUMERIC,
-    EXACT_NUMERIC,
-    DECIMAL,
-    INTEGER,
-    DATETIME,
-    DATETIME_INTERVAL,
-    MULTISET,
-    ARRAY,
-    MAP,
-    NULL,
-    ANY,
-    CURSOR,
-    COLUMN_LIST,
-    GEO,
-    VARIANT,
-    FUNCTION,
-    /** Like ANY, but do not even validate the operand. It may not be an expression. */
-    IGNORE;
-
-    private static final Map<Integer, SqlTypeFamily> JDBC_TYPE_TO_FAMILY =
-            ImmutableMap.<Integer, SqlTypeFamily>builder()
-                    // Not present:
-                    // SqlTypeName.MULTISET shares Types.ARRAY with SqlTypeName.ARRAY;
-                    // SqlTypeName.MAP has no corresponding JDBC type
-                    // SqlTypeName.COLUMN_LIST has no corresponding JDBC type
-                    .put(Types.BIT, NUMERIC)
-                    .put(Types.TINYINT, NUMERIC)
-                    .put(Types.SMALLINT, NUMERIC)
-                    .put(Types.BIGINT, NUMERIC)
-                    .put(Types.INTEGER, NUMERIC)
-                    .put(Types.NUMERIC, NUMERIC)
-                    .put(Types.DECIMAL, NUMERIC)
-                    .put(Types.FLOAT, NUMERIC)
-                    .put(Types.REAL, NUMERIC)
-                    .put(Types.DOUBLE, NUMERIC)
-                    .put(Types.CHAR, CHARACTER)
-                    .put(Types.VARCHAR, CHARACTER)
-                    .put(Types.LONGVARCHAR, CHARACTER)
-                    .put(Types.CLOB, CHARACTER)
-                    .put(Types.BINARY, BINARY)
-                    .put(Types.VARBINARY, BINARY)
-                    .put(Types.LONGVARBINARY, BINARY)
-                    .put(Types.BLOB, BINARY)
-                    .put(Types.DATE, DATE)
-                    .put(Types.TIME, TIME)
-                    .put(ExtraSqlTypes.TIME_WITH_TIMEZONE, TIME)
-                    .put(Types.TIMESTAMP, TIMESTAMP)
-                    .put(ExtraSqlTypes.TIMESTAMP_WITH_TIMEZONE, TIMESTAMP)
-                    .put(Types.BOOLEAN, BOOLEAN)
-                    .put(ExtraSqlTypes.REF_CURSOR, CURSOR)
-                    .put(Types.ARRAY, ARRAY)
-                    .put(Types.JAVA_OBJECT, VARIANT)
-                    .build();
-
-    /**
-     * Gets the primary family containing a JDBC type.
-     *
-     * @param jdbcType the JDBC type of interest
-     * @return containing family
-     */
-    public static @Nullable SqlTypeFamily getFamilyForJdbcType(int jdbcType) {
-        return JDBC_TYPE_TO_FAMILY.get(jdbcType);
-    }
-
-    /**
-     * For this type family, returns the allow types of the difference between two values of this
-     * family.
-     *
-     * <p>Equivalently, given an {@code ORDER BY} expression with one key, returns the allowable
-     * type families of the difference between two keys.
-     *
-     * <p>Example 1. For {@code ORDER BY empno}, a NUMERIC, the difference between two {@code empno}
-     * values is also NUMERIC.
-     *
-     * <p>Example 2. For {@code ORDER BY hireDate}, a DATE, the difference between two {@code
-     * hireDate} values might be an INTERVAL_DAY_TIME or INTERVAL_YEAR_MONTH.
-     *
-     * <p>The result determines whether a {@link SqlWindow} with a {@code RANGE} is valid (for
-     * example, {@code OVER (ORDER BY empno RANGE 10} is valid because {@code 10} is numeric); and
-     * whether a call to {@link org.apache.calcite.sql.fun.SqlStdOperatorTable#PERCENTILE_CONT
-     * PERCENTILE_CONT} is valid (for example, {@code PERCENTILE_CONT(0.25)} ORDER BY (hireDate)} is
-     * valid because {@code hireDate} values may be interpolated by adding values of type {@code
-     * INTERVAL_DAY_TIME}.
-     */
-    public List<SqlTypeFamily> allowableDifferenceTypes() {
-        switch (this) {
-            case NUMERIC:
-                return ImmutableList.of(NUMERIC);
-            case DATE:
-            case TIME:
-            case TIMESTAMP:
-                return ImmutableList.of(INTERVAL_DAY_TIME, INTERVAL_YEAR_MONTH);
-            default:
-                return ImmutableList.of();
-        }
-    }
-
-    /** Returns the collection of {@link SqlTypeName}s included in this family. */
-    public Collection<SqlTypeName> getTypeNames() {
-        switch (this) {
-            case CHARACTER:
-                return SqlTypeName.CHAR_TYPES;
-            case BINARY:
-                return SqlTypeName.BINARY_TYPES;
-            case NUMERIC:
-                return SqlTypeName.NUMERIC_TYPES;
-            case DECIMAL:
-                return ImmutableList.of(SqlTypeName.DECIMAL);
-            case DATE:
-                return ImmutableList.of(SqlTypeName.DATE);
-            case TIME:
-                return ImmutableList.of(
-                        SqlTypeName.TIME,
-                        SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE,
-                        SqlTypeName.TIME_TZ);
-            case TIMESTAMP:
-                return ImmutableList.of(
-                        SqlTypeName.TIMESTAMP,
-                        SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE,
-                        SqlTypeName.TIMESTAMP_TZ);
-            case BOOLEAN:
-                return SqlTypeName.BOOLEAN_TYPES;
-            case INTERVAL_YEAR_MONTH:
-                return SqlTypeName.YEAR_INTERVAL_TYPES;
-            case INTERVAL_DAY_TIME:
-                return SqlTypeName.DAY_INTERVAL_TYPES;
-            case STRING:
-                return SqlTypeName.STRING_TYPES;
-            case APPROXIMATE_NUMERIC:
-                return SqlTypeName.APPROX_TYPES;
-            case EXACT_NUMERIC:
-                return SqlTypeName.EXACT_TYPES;
-            case INTEGER:
-                return SqlTypeName.INT_TYPES;
-            case DATETIME:
-                return SqlTypeName.DATETIME_TYPES;
-            case DATETIME_INTERVAL:
-                return SqlTypeName.INTERVAL_TYPES;
-            case GEO:
-                return SqlTypeName.GEOMETRY_TYPES;
-            case MULTISET:
-                return ImmutableList.of(SqlTypeName.MULTISET);
-            case ARRAY:
-                return ImmutableList.of(SqlTypeName.ARRAY);
-            case MAP:
-                return ImmutableList.of(SqlTypeName.MAP);
-            case NULL:
-                return ImmutableList.of(SqlTypeName.NULL);
-            case ANY:
-                return SqlTypeName.ALL_TYPES;
-            case CURSOR:
-                return ImmutableList.of(SqlTypeName.CURSOR);
-            case COLUMN_LIST:
-                return ImmutableList.of(SqlTypeName.COLUMN_LIST);
-            case FUNCTION:
-                return ImmutableList.of(SqlTypeName.FUNCTION);
-            case VARIANT:
-                return ImmutableList.of(SqlTypeName.VARIANT);
-            default:
-                throw new IllegalArgumentException();
-        }
-    }
-
-    /** Return the default {@link RelDataType} that belongs to this family. */
-    public @Nullable RelDataType getDefaultConcreteType(RelDataTypeFactory factory) {
-        switch (this) {
-            case CHARACTER:
-                return factory.createSqlType(SqlTypeName.VARCHAR);
-            case BINARY:
-                return factory.createSqlType(SqlTypeName.VARBINARY);
-            case NUMERIC:
-                return SqlTypeUtil.getMaxPrecisionScaleDecimal(factory);
-            case DATE:
-                return factory.createSqlType(SqlTypeName.DATE);
-            case TIME:
-                return factory.createSqlType(SqlTypeName.TIME);
-            case TIMESTAMP:
-                return factory.createSqlType(SqlTypeName.TIMESTAMP);
-            case BOOLEAN:
-                return factory.createSqlType(SqlTypeName.BOOLEAN);
-            case STRING:
-                return factory.createSqlType(SqlTypeName.VARCHAR);
-            case APPROXIMATE_NUMERIC:
-                return factory.createSqlType(SqlTypeName.DOUBLE);
-            case EXACT_NUMERIC:
-                return SqlTypeUtil.getMaxPrecisionScaleDecimal(factory);
-            case INTEGER:
-                return factory.createSqlType(SqlTypeName.BIGINT);
-            case DECIMAL:
-                return factory.createSqlType(SqlTypeName.DECIMAL);
-            case DATETIME:
-                return factory.createSqlType(SqlTypeName.TIMESTAMP);
-            case INTERVAL_DAY_TIME:
-                return factory.createSqlIntervalType(
-                        new SqlIntervalQualifier(TimeUnit.DAY, TimeUnit.SECOND, SqlParserPos.ZERO));
-            case INTERVAL_YEAR_MONTH:
-                return factory.createSqlIntervalType(
-                        new SqlIntervalQualifier(TimeUnit.YEAR, TimeUnit.MONTH, SqlParserPos.ZERO));
-            case GEO:
-                return factory.createSqlType(SqlTypeName.GEOMETRY);
-            case MULTISET:
-                return factory.createMultisetType(factory.createSqlType(SqlTypeName.ANY), -1);
-            case ARRAY:
-                return factory.createArrayType(factory.createSqlType(SqlTypeName.ANY), -1);
-            case MAP:
-                return factory.createMapType(
-                        factory.createSqlType(SqlTypeName.ANY),
-                        factory.createSqlType(SqlTypeName.ANY));
-            case NULL:
-                return factory.createSqlType(SqlTypeName.NULL);
-            case CURSOR:
-                return factory.createSqlType(SqlTypeName.CURSOR);
-            case COLUMN_LIST:
-                return factory.createSqlType(SqlTypeName.COLUMN_LIST);
-            case FUNCTION:
-                return factory.createFunctionSqlType(
-                        factory.createStructType(ImmutableList.of(), ImmutableList.of()),
-                        factory.createSqlType(SqlTypeName.ANY));
-            default:
-                return null;
-        }
-    }
-
-    public boolean contains(RelDataType type) {
-        return SqlTypeUtil.isOfSameTypeName(getTypeNames(), type);
-    }
-}
diff --git a/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java b/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
deleted file mode 100644
index 5f76b4493b1a6..0000000000000
--- a/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
+++ /dev/null
@@ -1,1078 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.sql.type;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Sets;
-import org.apache.calcite.avatica.util.TimeUnit;
-import org.apache.calcite.sql.SqlLiteral;
-import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.util.DateString;
-import org.apache.calcite.util.TimeString;
-import org.apache.calcite.util.TimestampString;
-import org.apache.calcite.util.Util;
-import org.checkerframework.checker.nullness.qual.Nullable;
-
-import java.math.BigDecimal;
-import java.sql.Types;
-import java.util.Arrays;
-import java.util.Calendar;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Enumeration of the type names which can be used to construct a SQL type. Rationale for this
- * class's existence (instead of just using the standard java.sql.Type ordinals):
- *
- * <ul>
- *   <li>{@link Types} does not include all SQL2003 data-types;
- *   <li>SqlTypeName provides a type-safe enumeration;
- *   <li>SqlTypeName provides a place to hang extra information such as whether the type carries
- *       precision and scale.
- * </ul>
- *
- * <p>This class was copied over from Calcite to support variant type(CALCITE-4918). When upgrading
- * to Calcite 1.39.0 version, please remove the entire class.
- */
-public enum SqlTypeName {
-    BOOLEAN(PrecScale.NO_NO, false, Types.BOOLEAN, SqlTypeFamily.BOOLEAN),
-    TINYINT(PrecScale.NO_NO, false, Types.TINYINT, SqlTypeFamily.NUMERIC),
-    SMALLINT(PrecScale.NO_NO, false, Types.SMALLINT, SqlTypeFamily.NUMERIC),
-    INTEGER(PrecScale.NO_NO, false, Types.INTEGER, SqlTypeFamily.NUMERIC),
-    BIGINT(PrecScale.NO_NO, false, Types.BIGINT, SqlTypeFamily.NUMERIC),
-    DECIMAL(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            false,
-            Types.DECIMAL,
-            SqlTypeFamily.NUMERIC),
-    FLOAT(PrecScale.NO_NO, false, Types.FLOAT, SqlTypeFamily.NUMERIC),
-    REAL(PrecScale.NO_NO, false, Types.REAL, SqlTypeFamily.NUMERIC),
-    DOUBLE(PrecScale.NO_NO, false, Types.DOUBLE, SqlTypeFamily.NUMERIC),
-    DATE(PrecScale.NO_NO, false, Types.DATE, SqlTypeFamily.DATE),
-    TIME(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.TIME, SqlTypeFamily.TIME),
-    TIME_WITH_LOCAL_TIME_ZONE(
-            PrecScale.NO_NO | PrecScale.YES_NO, false, Types.TIME, SqlTypeFamily.TIME),
-    TIME_TZ(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.TIME, SqlTypeFamily.TIME),
-    TIMESTAMP(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.TIMESTAMP, SqlTypeFamily.TIMESTAMP),
-    TIMESTAMP_WITH_LOCAL_TIME_ZONE(
-            PrecScale.NO_NO | PrecScale.YES_NO, false, Types.TIMESTAMP, SqlTypeFamily.TIMESTAMP),
-    TIMESTAMP_TZ(
-            PrecScale.NO_NO | PrecScale.YES_NO, false, Types.TIMESTAMP, SqlTypeFamily.TIMESTAMP),
-    INTERVAL_YEAR(PrecScale.NO_NO, false, Types.OTHER, SqlTypeFamily.INTERVAL_YEAR_MONTH),
-    INTERVAL_YEAR_MONTH(PrecScale.NO_NO, false, Types.OTHER, SqlTypeFamily.INTERVAL_YEAR_MONTH),
-    INTERVAL_MONTH(PrecScale.NO_NO, false, Types.OTHER, SqlTypeFamily.INTERVAL_YEAR_MONTH),
-    INTERVAL_DAY(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            false,
-            Types.OTHER,
-            SqlTypeFamily.INTERVAL_DAY_TIME),
-    INTERVAL_DAY_HOUR(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            false,
-            Types.OTHER,
-            SqlTypeFamily.INTERVAL_DAY_TIME),
-    INTERVAL_DAY_MINUTE(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            false,
-            Types.OTHER,
-            SqlTypeFamily.INTERVAL_DAY_TIME),
-    INTERVAL_DAY_SECOND(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            false,
-            Types.OTHER,
-            SqlTypeFamily.INTERVAL_DAY_TIME),
-    INTERVAL_HOUR(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            false,
-            Types.OTHER,
-            SqlTypeFamily.INTERVAL_DAY_TIME),
-    INTERVAL_HOUR_MINUTE(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            false,
-            Types.OTHER,
-            SqlTypeFamily.INTERVAL_DAY_TIME),
-    INTERVAL_HOUR_SECOND(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            false,
-            Types.OTHER,
-            SqlTypeFamily.INTERVAL_DAY_TIME),
-    INTERVAL_MINUTE(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            false,
-            Types.OTHER,
-            SqlTypeFamily.INTERVAL_DAY_TIME),
-    INTERVAL_MINUTE_SECOND(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            false,
-            Types.OTHER,
-            SqlTypeFamily.INTERVAL_DAY_TIME),
-    INTERVAL_SECOND(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            false,
-            Types.OTHER,
-            SqlTypeFamily.INTERVAL_DAY_TIME),
-    CHAR(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.CHAR, SqlTypeFamily.CHARACTER),
-    VARCHAR(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.VARCHAR, SqlTypeFamily.CHARACTER),
-    BINARY(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.BINARY, SqlTypeFamily.BINARY),
-    VARBINARY(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.VARBINARY, SqlTypeFamily.BINARY),
-    NULL(PrecScale.NO_NO, true, Types.NULL, SqlTypeFamily.NULL),
-    UNKNOWN(PrecScale.NO_NO, true, Types.NULL, SqlTypeFamily.NULL),
-    ANY(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            true,
-            Types.JAVA_OBJECT,
-            SqlTypeFamily.ANY),
-    SYMBOL(PrecScale.NO_NO, true, Types.OTHER, null),
-    MULTISET(PrecScale.NO_NO, false, Types.ARRAY, SqlTypeFamily.MULTISET),
-    ARRAY(PrecScale.NO_NO, false, Types.ARRAY, SqlTypeFamily.ARRAY),
-    MAP(PrecScale.NO_NO, false, Types.OTHER, SqlTypeFamily.MAP),
-    DISTINCT(PrecScale.NO_NO, false, Types.DISTINCT, null),
-    STRUCTURED(PrecScale.NO_NO, false, Types.STRUCT, null),
-    ROW(PrecScale.NO_NO, false, Types.STRUCT, null),
-    OTHER(PrecScale.NO_NO, false, Types.OTHER, null),
-    CURSOR(PrecScale.NO_NO, false, ExtraSqlTypes.REF_CURSOR, SqlTypeFamily.CURSOR),
-    COLUMN_LIST(PrecScale.NO_NO, false, Types.OTHER + 2, SqlTypeFamily.COLUMN_LIST),
-    DYNAMIC_STAR(
-            PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES,
-            true,
-            Types.JAVA_OBJECT,
-            SqlTypeFamily.ANY),
-    /**
-     * Spatial type. Though not standard, it is common to several DBs, so we do not flag it
-     * 'special' (internal).
-     */
-    GEOMETRY(PrecScale.NO_NO, false, ExtraSqlTypes.GEOMETRY, SqlTypeFamily.GEO),
-    MEASURE(PrecScale.NO_NO, true, Types.OTHER, SqlTypeFamily.ANY),
-    FUNCTION(PrecScale.NO_NO, true, Types.OTHER, SqlTypeFamily.FUNCTION),
-    SARG(PrecScale.NO_NO, true, Types.OTHER, SqlTypeFamily.ANY),
-    /**
-     * VARIANT data type, a dynamically-typed value that can have at runtime any of the other data
-     * types in this table.
-     */
-    VARIANT(PrecScale.NO_NO, false, Types.OTHER, SqlTypeFamily.VARIANT);
-
-    public static final int MAX_DATETIME_PRECISION = 3;
-
-    // Minimum and default interval precisions are  defined by SQL2003
-    // Maximum interval precisions are implementation dependent,
-    //  but must be at least the default value
-    public static final int DEFAULT_INTERVAL_START_PRECISION = 2;
-    public static final int DEFAULT_INTERVAL_FRACTIONAL_SECOND_PRECISION = 6;
-    public static final int MIN_INTERVAL_START_PRECISION = 1;
-    public static final int MIN_INTERVAL_FRACTIONAL_SECOND_PRECISION = 0;
-    public static final int MAX_INTERVAL_START_PRECISION = 10;
-    public static final int MAX_INTERVAL_FRACTIONAL_SECOND_PRECISION = 9;
-
-    // Cached map of enum values
-    private static final Map<String, SqlTypeName> VALUES_MAP =
-            Util.enumConstants(SqlTypeName.class);
-
-    // categorizations used by SqlTypeFamily definitions
-
-    // you probably want to use JDK 1.5 support for treating enumeration
-    // as collection instead; this is only here to support
-    // SqlTypeFamily.ANY
-    public static final List<SqlTypeName> ALL_TYPES =
-            ImmutableList.of(
-                    BOOLEAN,
-                    INTEGER,
-                    VARCHAR,
-                    DATE,
-                    TIME,
-                    TIMESTAMP,
-                    NULL,
-                    DECIMAL,
-                    ANY,
-                    CHAR,
-                    BINARY,
-                    VARBINARY,
-                    TINYINT,
-                    SMALLINT,
-                    BIGINT,
-                    REAL,
-                    DOUBLE,
-                    SYMBOL,
-                    INTERVAL_YEAR,
-                    INTERVAL_YEAR_MONTH,
-                    INTERVAL_MONTH,
-                    INTERVAL_DAY,
-                    INTERVAL_DAY_HOUR,
-                    INTERVAL_DAY_MINUTE,
-                    INTERVAL_DAY_SECOND,
-                    INTERVAL_HOUR,
-                    INTERVAL_HOUR_MINUTE,
-                    INTERVAL_HOUR_SECOND,
-                    INTERVAL_MINUTE,
-                    INTERVAL_MINUTE_SECOND,
-                    INTERVAL_SECOND,
-                    TIME_WITH_LOCAL_TIME_ZONE,
-                    TIME_TZ,
-                    TIMESTAMP_WITH_LOCAL_TIME_ZONE,
-                    TIMESTAMP_TZ,
-                    FLOAT,
-                    MULTISET,
-                    DISTINCT,
-                    STRUCTURED,
-                    ROW,
-                    CURSOR,
-                    COLUMN_LIST,
-                    VARIANT);
-
-    public static final List<SqlTypeName> BOOLEAN_TYPES = ImmutableList.of(BOOLEAN);
-
-    public static final List<SqlTypeName> BINARY_TYPES = ImmutableList.of(BINARY, VARBINARY);
-
-    public static final List<SqlTypeName> INT_TYPES =
-            ImmutableList.of(TINYINT, SMALLINT, INTEGER, BIGINT);
-
-    public static final List<SqlTypeName> EXACT_TYPES =
-            combine(INT_TYPES, ImmutableList.of(DECIMAL));
-
-    public static final List<SqlTypeName> APPROX_TYPES = ImmutableList.of(FLOAT, REAL, DOUBLE);
-
-    public static final List<SqlTypeName> NUMERIC_TYPES = combine(EXACT_TYPES, APPROX_TYPES);
-
-    public static final List<SqlTypeName> FRACTIONAL_TYPES =
-            combine(APPROX_TYPES, ImmutableList.of(DECIMAL));
-
-    public static final List<SqlTypeName> CHAR_TYPES = ImmutableList.of(CHAR, VARCHAR);
-
-    public static final List<SqlTypeName> STRING_TYPES = combine(CHAR_TYPES, BINARY_TYPES);
-
-    public static final List<SqlTypeName> GEOMETRY_TYPES = ImmutableList.of(GEOMETRY);
-
-    public static final List<SqlTypeName> DATETIME_TYPES =
-            ImmutableList.of(
-                    DATE,
-                    TIME,
-                    TIME_WITH_LOCAL_TIME_ZONE,
-                    TIME_TZ,
-                    TIMESTAMP,
-                    TIMESTAMP_WITH_LOCAL_TIME_ZONE,
-                    TIMESTAMP_TZ);
-
-    /** Types that contain time zone information. */
-    public static final List<SqlTypeName> TZ_TYPES =
-            ImmutableList.of(
-                    TIME_WITH_LOCAL_TIME_ZONE,
-                    TIME_TZ,
-                    TIMESTAMP_WITH_LOCAL_TIME_ZONE,
-                    TIMESTAMP_TZ);
-
-    public static final Set<SqlTypeName> YEAR_INTERVAL_TYPES =
-            Sets.immutableEnumSet(
-                    SqlTypeName.INTERVAL_YEAR,
-                    SqlTypeName.INTERVAL_YEAR_MONTH,
-                    SqlTypeName.INTERVAL_MONTH);
-
-    public static final Set<SqlTypeName> DAY_INTERVAL_TYPES =
-            Sets.immutableEnumSet(
-                    SqlTypeName.INTERVAL_DAY,
-                    SqlTypeName.INTERVAL_DAY_HOUR,
-                    SqlTypeName.INTERVAL_DAY_MINUTE,
-                    SqlTypeName.INTERVAL_DAY_SECOND,
-                    SqlTypeName.INTERVAL_HOUR,
-                    SqlTypeName.INTERVAL_HOUR_MINUTE,
-                    SqlTypeName.INTERVAL_HOUR_SECOND,
-                    SqlTypeName.INTERVAL_MINUTE,
-                    SqlTypeName.INTERVAL_MINUTE_SECOND,
-                    SqlTypeName.INTERVAL_SECOND);
-
-    public static final Set<SqlTypeName> INTERVAL_TYPES =
-            Sets.immutableEnumSet(Iterables.concat(YEAR_INTERVAL_TYPES, DAY_INTERVAL_TYPES));
-
-    /** The possible types of a time frame argument to a function such as {@code TIMESTAMP_DIFF}. */
-    public static final Set<SqlTypeName> TIME_FRAME_TYPES =
-            Sets.immutableEnumSet(Iterables.concat(INTERVAL_TYPES, ImmutableList.of(SYMBOL)));
-
-    private static final Map<Integer, SqlTypeName> JDBC_TYPE_TO_NAME =
-            ImmutableMap.<Integer, SqlTypeName>builder()
-                    .put(Types.TINYINT, TINYINT)
-                    .put(Types.SMALLINT, SMALLINT)
-                    .put(Types.BIGINT, BIGINT)
-                    .put(Types.INTEGER, INTEGER)
-                    .put(Types.NUMERIC, DECIMAL) // REVIEW
-                    .put(Types.DECIMAL, DECIMAL)
-                    .put(Types.FLOAT, FLOAT)
-                    .put(Types.REAL, REAL)
-                    .put(Types.DOUBLE, DOUBLE)
-                    .put(Types.CHAR, CHAR)
-                    .put(Types.VARCHAR, VARCHAR)
-
-                    // TODO: provide real support for these eventually
-                    .put(ExtraSqlTypes.NCHAR, CHAR)
-                    .put(ExtraSqlTypes.NVARCHAR, VARCHAR)
-
-                    // TODO: additional types not yet supported. See ExtraSqlTypes.
-                    // .put(Types.LONGVARCHAR, Longvarchar)
-                    // .put(Types.CLOB, Clob)
-                    // .put(Types.LONGVARBINARY, Longvarbinary)
-                    // .put(Types.BLOB, Blob)
-                    // .put(Types.LONGNVARCHAR, Longnvarchar)
-                    // .put(Types.NCLOB, Nclob)
-                    // .put(Types.ROWID, Rowid)
-                    // .put(Types.SQLXML, Sqlxml)
-
-                    .put(Types.BINARY, BINARY)
-                    .put(Types.VARBINARY, VARBINARY)
-                    .put(Types.DATE, DATE)
-                    .put(Types.TIME, TIME)
-                    .put(Types.TIMESTAMP, TIMESTAMP)
-                    .put(Types.BIT, BOOLEAN)
-                    .put(Types.BOOLEAN, BOOLEAN)
-                    .put(Types.DISTINCT, DISTINCT)
-                    .put(Types.STRUCT, STRUCTURED)
-                    .put(Types.ARRAY, ARRAY)
-                    .build();
-
-    /** Bitwise-or of flags indicating allowable precision/scale combinations. */
-    private final int signatures;
-
-    /**
-     * Returns true if not of a "pure" standard sql type. "Inpure" types are {@link #ANY}, {@link
-     * #NULL} and {@link #SYMBOL}
-     */
-    private final boolean special;
-
-    private final int jdbcOrdinal;
-    private final @Nullable SqlTypeFamily family;
-
-    SqlTypeName(int signatures, boolean special, int jdbcType, @Nullable SqlTypeFamily family) {
-        this.signatures = signatures;
-        this.special = special;
-        this.jdbcOrdinal = jdbcType;
-        this.family = family;
-    }
-
-    /**
-     * Looks up a type name from its name.
-     *
-     * @return Type name, or null if not found
-     */
-    public static @Nullable SqlTypeName get(String name) {
-        if (false) {
-            // The following code works OK, but the spurious exceptions are
-            // annoying.
-            try {
-                return SqlTypeName.valueOf(name);
-            } catch (IllegalArgumentException e) {
-                return null;
-            }
-        }
-        return VALUES_MAP.get(name);
-    }
-
-    /**
-     * Returns the SqlTypeName value whose name or {@link #getSpaceName()} matches the given name,
-     * or throws {@link IllegalArgumentException}; never returns null.
-     */
-    public static SqlTypeName lookup(String tag) {
-        // Special handling for TIME WITH TIME ZONE and
-        // TIMESTAMP WITH TIME ZONE, whose type names are TIME_TZ and TIMESTAMP_TZ.
-        // We know that the type name is always uppercase, because it is
-        // inserted in the tag by the parser.
-        final String tag1 = tag.replace("WITH TIME ZONE", "TZ");
-        final String tag2 = tag1.replace(' ', '_');
-        return valueOf(tag2);
-    }
-
-    public boolean allowsNoPrecNoScale() {
-        return (signatures & PrecScale.NO_NO) != 0;
-    }
-
-    public boolean allowsPrecNoScale() {
-        return (signatures & PrecScale.YES_NO) != 0;
-    }
-
-    public boolean allowsPrec() {
-        return allowsPrecScale(true, true) || allowsPrecScale(true, false);
-    }
-
-    public boolean allowsScale() {
-        return allowsPrecScale(true, true);
-    }
-
-    /**
-     * Returns whether this type can be specified with a given combination of precision and scale.
-     * For example,
-     *
-     * <ul>
-     *   <li><code>Varchar.allowsPrecScale(true, false)</code> returns <code>
-     * true</code>, because the VARCHAR type allows a precision parameter, as in <code>VARCHAR(10)
-     *       </code>.
-     *   <li><code>Varchar.allowsPrecScale(true, true)</code> returns <code>
-     * false</code>, because the VARCHAR type does not allow a precision and a scale parameter, as
-     *       in <code>VARCHAR(10, 4)</code>.
-     *   <li><code>allowsPrecScale(false, true)</code> returns <code>false</code> for every type.
-     * </ul>
-     *
-     * @param precision Whether the precision/length field is part of the type specification
-     * @param scale Whether the scale field is part of the type specification
-     * @return Whether this combination of precision/scale is valid
-     */
-    public boolean allowsPrecScale(boolean precision, boolean scale) {
-        int mask =
-                precision
-                        ? (scale ? PrecScale.YES_YES : PrecScale.YES_NO)
-                        : (scale ? 0 : PrecScale.NO_NO);
-        return (signatures & mask) != 0;
-    }
-
-    public boolean isSpecial() {
-        return special;
-    }
-
-    /** Returns the ordinal from {@link java.sql.Types} corresponding to this SqlTypeName. */
-    public int getJdbcOrdinal() {
-        return jdbcOrdinal;
-    }
-
-    private static List<SqlTypeName> combine(List<SqlTypeName> list0, List<SqlTypeName> list1) {
-        return ImmutableList.<SqlTypeName>builder().addAll(list0).addAll(list1).build();
-    }
-
-    /**
-     * Returns the default scale for this type if supported, otherwise -1 if scale is either
-     * unsupported or must be specified explicitly.
-     */
-    public int getDefaultScale() {
-        switch (this) {
-            case DECIMAL:
-                return 0;
-            case INTERVAL_YEAR:
-            case INTERVAL_YEAR_MONTH:
-            case INTERVAL_MONTH:
-            case INTERVAL_DAY:
-            case INTERVAL_DAY_HOUR:
-            case INTERVAL_DAY_MINUTE:
-            case INTERVAL_DAY_SECOND:
-            case INTERVAL_HOUR:
-            case INTERVAL_HOUR_MINUTE:
-            case INTERVAL_HOUR_SECOND:
-            case INTERVAL_MINUTE:
-            case INTERVAL_MINUTE_SECOND:
-            case INTERVAL_SECOND:
-                return DEFAULT_INTERVAL_FRACTIONAL_SECOND_PRECISION;
-            default:
-                return -1;
-        }
-    }
-
-    /**
-     * Gets the SqlTypeFamily containing this SqlTypeName.
-     *
-     * @return containing family, or null for none (SYMBOL, DISTINCT, STRUCTURED, ROW, OTHER)
-     */
-    public @Nullable SqlTypeFamily getFamily() {
-        return family;
-    }
-
-    /**
-     * Gets the SqlTypeName corresponding to a JDBC type.
-     *
-     * @param jdbcType the JDBC type of interest
-     * @return corresponding SqlTypeName, or null if the type is not known
-     */
-    public static @Nullable SqlTypeName getNameForJdbcType(int jdbcType) {
-        return JDBC_TYPE_TO_NAME.get(jdbcType);
-    }
-
-    /**
-     * Returns the limit of this datatype. For example,
-     *
-     * <table border="1">
-     * <caption>Datatype limits</caption>
-     * <tr>
-     * <th>Datatype</th>
-     * <th>sign</th>
-     * <th>limit</th>
-     * <th>beyond</th>
-     * <th>precision</th>
-     * <th>scale</th>
-     * <th>Returns</th>
-     * </tr>
-     * <tr>
-     * <td>Integer</td>
-     * <td>true</td>
-     * <td>true</td>
-     * <td>false</td>
-     * <td>-1</td>
-     * <td>-1</td>
-     * <td>2147483647 (2 ^ 31 -1 = MAXINT)</td>
-     * </tr>
-     * <tr>
-     * <td>Integer</td>
-     * <td>true</td>
-     * <td>true</td>
-     * <td>true</td>
-     * <td>-1</td>
-     * <td>-1</td>
-     * <td>2147483648 (2 ^ 31 = MAXINT + 1)</td>
-     * </tr>
-     * <tr>
-     * <td>Integer</td>
-     * <td>false</td>
-     * <td>true</td>
-     * <td>false</td>
-     * <td>-1</td>
-     * <td>-1</td>
-     * <td>-2147483648 (-2 ^ 31 = MININT)</td>
-     * </tr>
-     * <tr>
-     * <td>Boolean</td>
-     * <td>true</td>
-     * <td>true</td>
-     * <td>false</td>
-     * <td>-1</td>
-     * <td>-1</td>
-     * <td>TRUE</td>
-     * </tr>
-     * <tr>
-     * <td>Varchar</td>
-     * <td>true</td>
-     * <td>true</td>
-     * <td>false</td>
-     * <td>10</td>
-     * <td>-1</td>
-     * <td>'ZZZZZZZZZZ'</td>
-     * </tr>
-     * </table>
-     *
-     * @param sign If true, returns upper limit, otherwise lower limit
-     * @param limit If true, returns value at or near to overflow; otherwise value at or near to
-     *     underflow
-     * @param beyond If true, returns the value just beyond the limit, otherwise the value at the
-     *     limit
-     * @param precision Precision, or -1 if not applicable
-     * @param scale Scale, or -1 if not applicable
-     * @return Limit value
-     */
-    public @Nullable Object getLimit(
-            boolean sign, Limit limit, boolean beyond, int precision, int scale) {
-        assert allowsPrecScale(precision != -1, scale != -1) : this;
-        if (limit == Limit.ZERO) {
-            if (beyond) {
-                return null;
-            }
-            sign = true;
-        }
-        Calendar calendar;
-
-        switch (this) {
-            case BOOLEAN:
-                switch (limit) {
-                    case ZERO:
-                        return false;
-                    case UNDERFLOW:
-                        return null;
-                    case OVERFLOW:
-                        if (beyond || !sign) {
-                            return null;
-                        } else {
-                            return true;
-                        }
-                    default:
-                        throw Util.unexpected(limit);
-                }
-
-            case TINYINT:
-                return getNumericLimit(2, 8, sign, limit, beyond);
-
-            case SMALLINT:
-                return getNumericLimit(2, 16, sign, limit, beyond);
-
-            case INTEGER:
-                return getNumericLimit(2, 32, sign, limit, beyond);
-
-            case BIGINT:
-                return getNumericLimit(2, 64, sign, limit, beyond);
-
-            case DECIMAL:
-                BigDecimal decimal = getNumericLimit(10, precision, sign, limit, beyond);
-                if (decimal == null) {
-                    return null;
-                }
-
-                // Decimal values must fit into 64 bits. So, the maximum value of
-                // a DECIMAL(19, 0) is 2^63 - 1, not 10^19 - 1.
-                switch (limit) {
-                    case OVERFLOW:
-                        final BigDecimal other =
-                                (BigDecimal) BIGINT.getLimit(sign, limit, beyond, -1, -1);
-                        if (other != null && decimal.compareTo(other) == (sign ? 1 : -1)) {
-                            decimal = other;
-                        }
-                        break;
-                    default:
-                        break;
-                }
-
-                // Apply scale.
-                if (scale == 0) {
-                    // do nothing
-                } else if (scale > 0) {
-                    decimal = decimal.divide(BigDecimal.TEN.pow(scale));
-                } else {
-                    decimal = decimal.multiply(BigDecimal.TEN.pow(-scale));
-                }
-                return decimal;
-
-            case CHAR:
-            case VARCHAR:
-                if (!sign) {
-                    return null; // this type does not have negative values
-                }
-                StringBuilder buf = new StringBuilder();
-                switch (limit) {
-                    case ZERO:
-                        break;
-                    case UNDERFLOW:
-                        if (beyond) {
-                            // There is no value between the empty string and the
-                            // smallest non-empty string.
-                            return null;
-                        }
-                        buf.append("a");
-                        break;
-                    case OVERFLOW:
-                        for (int i = 0; i < precision; ++i) {
-                            buf.append("Z");
-                        }
-                        if (beyond) {
-                            buf.append("Z");
-                        }
-                        break;
-                    default:
-                        break;
-                }
-                return buf.toString();
-
-            case BINARY:
-            case VARBINARY:
-                if (!sign) {
-                    return null; // this type does not have negative values
-                }
-                byte[] bytes;
-                switch (limit) {
-                    case ZERO:
-                        bytes = new byte[0];
-                        break;
-                    case UNDERFLOW:
-                        if (beyond) {
-                            // There is no value between the empty string and the
-                            // smallest value.
-                            return null;
-                        }
-                        bytes = new byte[] {0x00};
-                        break;
-                    case OVERFLOW:
-                        bytes = new byte[precision + (beyond ? 1 : 0)];
-                        Arrays.fill(bytes, (byte) 0xff);
-                        break;
-                    default:
-                        throw Util.unexpected(limit);
-                }
-                return bytes;
-
-            case DATE:
-                calendar = Util.calendar();
-                switch (limit) {
-                    case ZERO:
-                        // The epoch.
-                        calendar.set(Calendar.YEAR, 1970);
-                        calendar.set(Calendar.MONTH, 0);
-                        calendar.set(Calendar.DAY_OF_MONTH, 1);
-                        break;
-                    case UNDERFLOW:
-                        return null;
-                    case OVERFLOW:
-                        if (beyond) {
-                            // It is impossible to represent an invalid year as a date
-                            // literal. SQL dates are represented as 'yyyy-mm-dd', and
-                            // 1 <= yyyy <= 9999 is valid. There is no year 0: the year
-                            // before 1AD is 1BC, so SimpleDateFormat renders the day
-                            // before 0001-01-01 (AD) as 0001-12-31 (BC), which looks
-                            // like a valid date.
-                            return null;
-                        }
-
-                        // "SQL:2003 6.1 <data type> Access Rules 6" says that year is
-                        // between 1 and 9999, and days/months are the valid Gregorian
-                        // calendar values for these years.
-                        if (sign) {
-                            calendar.set(Calendar.YEAR, 9999);
-                            calendar.set(Calendar.MONTH, 11);
-                            calendar.set(Calendar.DAY_OF_MONTH, 31);
-                        } else {
-                            calendar.set(Calendar.YEAR, 1);
-                            calendar.set(Calendar.MONTH, 0);
-                            calendar.set(Calendar.DAY_OF_MONTH, 1);
-                        }
-                        break;
-                    default:
-                        break;
-                }
-                calendar.set(Calendar.HOUR_OF_DAY, 0);
-                calendar.set(Calendar.MINUTE, 0);
-                calendar.set(Calendar.SECOND, 0);
-                return calendar;
-
-            case TIME:
-                if (!sign) {
-                    return null; // this type does not have negative values
-                }
-                if (beyond) {
-                    return null; // invalid values are impossible to represent
-                }
-                calendar = Util.calendar();
-                switch (limit) {
-                    case ZERO:
-
-                        // The epoch.
-                        calendar.set(Calendar.HOUR_OF_DAY, 0);
-                        calendar.set(Calendar.MINUTE, 0);
-                        calendar.set(Calendar.SECOND, 0);
-                        calendar.set(Calendar.MILLISECOND, 0);
-                        break;
-                    case UNDERFLOW:
-                        return null;
-                    case OVERFLOW:
-                        calendar.set(Calendar.HOUR_OF_DAY, 23);
-                        calendar.set(Calendar.MINUTE, 59);
-                        calendar.set(Calendar.SECOND, 59);
-                        int millis =
-                                (precision >= 3)
-                                        ? 999
-                                        : ((precision == 2) ? 990 : ((precision == 1) ? 900 : 0));
-                        calendar.set(Calendar.MILLISECOND, millis);
-                        break;
-                    default:
-                        break;
-                }
-                return calendar;
-
-            case TIMESTAMP:
-                calendar = Util.calendar();
-                switch (limit) {
-                    case ZERO:
-                        // The epoch.
-                        calendar.set(Calendar.YEAR, 1970);
-                        calendar.set(Calendar.MONTH, 0);
-                        calendar.set(Calendar.DAY_OF_MONTH, 1);
-                        calendar.set(Calendar.HOUR_OF_DAY, 0);
-                        calendar.set(Calendar.MINUTE, 0);
-                        calendar.set(Calendar.SECOND, 0);
-                        calendar.set(Calendar.MILLISECOND, 0);
-                        break;
-                    case UNDERFLOW:
-                        return null;
-                    case OVERFLOW:
-                        if (beyond) {
-                            // It is impossible to represent an invalid year as a date
-                            // literal. SQL dates are represented as 'yyyy-mm-dd', and
-                            // 1 <= yyyy <= 9999 is valid. There is no year 0: the year
-                            // before 1AD is 1BC, so SimpleDateFormat renders the day
-                            // before 0001-01-01 (AD) as 0001-12-31 (BC), which looks
-                            // like a valid date.
-                            return null;
-                        }
-
-                        // "SQL:2003 6.1 <data type> Access Rules 6" says that year is
-                        // between 1 and 9999, and days/months are the valid Gregorian
-                        // calendar values for these years.
-                        if (sign) {
-                            calendar.set(Calendar.YEAR, 9999);
-                            calendar.set(Calendar.MONTH, 11);
-                            calendar.set(Calendar.DAY_OF_MONTH, 31);
-                            calendar.set(Calendar.HOUR_OF_DAY, 23);
-                            calendar.set(Calendar.MINUTE, 59);
-                            calendar.set(Calendar.SECOND, 59);
-                            int millis =
-                                    (precision >= 3)
-                                            ? 999
-                                            : ((precision == 2)
-                                                    ? 990
-                                                    : ((precision == 1) ? 900 : 0));
-                            calendar.set(Calendar.MILLISECOND, millis);
-                        } else {
-                            calendar.set(Calendar.YEAR, 1);
-                            calendar.set(Calendar.MONTH, 0);
-                            calendar.set(Calendar.DAY_OF_MONTH, 1);
-                            calendar.set(Calendar.HOUR_OF_DAY, 0);
-                            calendar.set(Calendar.MINUTE, 0);
-                            calendar.set(Calendar.SECOND, 0);
-                            calendar.set(Calendar.MILLISECOND, 0);
-                        }
-                        break;
-                    default:
-                        break;
-                }
-                return calendar;
-
-            default:
-                throw Util.unexpected(this);
-        }
-    }
-
-    /**
-     * Returns the minimum precision (or length) allowed for this type, or -1 if precision/length
-     * are not applicable for this type.
-     *
-     * @return Minimum allowed precision
-     */
-    public int getMinPrecision() {
-        switch (this) {
-            case DECIMAL:
-            case VARCHAR:
-            case CHAR:
-            case VARBINARY:
-            case BINARY:
-            case TIME:
-            case TIME_WITH_LOCAL_TIME_ZONE:
-            case TIME_TZ:
-            case TIMESTAMP:
-            case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-            case TIMESTAMP_TZ:
-                return 1;
-            case INTERVAL_YEAR:
-            case INTERVAL_YEAR_MONTH:
-            case INTERVAL_MONTH:
-            case INTERVAL_DAY:
-            case INTERVAL_DAY_HOUR:
-            case INTERVAL_DAY_MINUTE:
-            case INTERVAL_DAY_SECOND:
-            case INTERVAL_HOUR:
-            case INTERVAL_HOUR_MINUTE:
-            case INTERVAL_HOUR_SECOND:
-            case INTERVAL_MINUTE:
-            case INTERVAL_MINUTE_SECOND:
-            case INTERVAL_SECOND:
-                return MIN_INTERVAL_START_PRECISION;
-            default:
-                return -1;
-        }
-    }
-
-    /**
-     * Returns the minimum scale (or fractional second precision in the case of intervals) allowed
-     * for this type, or -1 if precision/length are not applicable for this type.
-     *
-     * @return Minimum allowed scale
-     */
-    public int getMinScale() {
-        switch (this) {
-            // TODO: Minimum numeric scale for decimal
-            case INTERVAL_YEAR:
-            case INTERVAL_YEAR_MONTH:
-            case INTERVAL_MONTH:
-            case INTERVAL_DAY:
-            case INTERVAL_DAY_HOUR:
-            case INTERVAL_DAY_MINUTE:
-            case INTERVAL_DAY_SECOND:
-            case INTERVAL_HOUR:
-            case INTERVAL_HOUR_MINUTE:
-            case INTERVAL_HOUR_SECOND:
-            case INTERVAL_MINUTE:
-            case INTERVAL_MINUTE_SECOND:
-            case INTERVAL_SECOND:
-                return MIN_INTERVAL_FRACTIONAL_SECOND_PRECISION;
-            default:
-                return -1;
-        }
-    }
-
-    /**
-     * Returns {@code HOUR} for {@code HOUR TO SECOND} and {@code HOUR}, {@code SECOND} for {@code
-     * SECOND}.
-     */
-    public TimeUnit getStartUnit() {
-        switch (this) {
-            case INTERVAL_YEAR:
-            case INTERVAL_YEAR_MONTH:
-                return TimeUnit.YEAR;
-            case INTERVAL_MONTH:
-                return TimeUnit.MONTH;
-            case INTERVAL_DAY:
-            case INTERVAL_DAY_HOUR:
-            case INTERVAL_DAY_MINUTE:
-            case INTERVAL_DAY_SECOND:
-                return TimeUnit.DAY;
-            case INTERVAL_HOUR:
-            case INTERVAL_HOUR_MINUTE:
-            case INTERVAL_HOUR_SECOND:
-                return TimeUnit.HOUR;
-            case INTERVAL_MINUTE:
-            case INTERVAL_MINUTE_SECOND:
-                return TimeUnit.MINUTE;
-            case INTERVAL_SECOND:
-                return TimeUnit.SECOND;
-            default:
-                throw new AssertionError(this);
-        }
-    }
-
-    /** Returns {@code SECOND} for both {@code HOUR TO SECOND} and {@code SECOND}. */
-    public TimeUnit getEndUnit() {
-        switch (this) {
-            case INTERVAL_YEAR:
-                return TimeUnit.YEAR;
-            case INTERVAL_YEAR_MONTH:
-            case INTERVAL_MONTH:
-                return TimeUnit.MONTH;
-            case INTERVAL_DAY:
-                return TimeUnit.DAY;
-            case INTERVAL_DAY_HOUR:
-            case INTERVAL_HOUR:
-                return TimeUnit.HOUR;
-            case INTERVAL_DAY_MINUTE:
-            case INTERVAL_HOUR_MINUTE:
-            case INTERVAL_MINUTE:
-                return TimeUnit.MINUTE;
-            case INTERVAL_DAY_SECOND:
-            case INTERVAL_HOUR_SECOND:
-            case INTERVAL_MINUTE_SECOND:
-            case INTERVAL_SECOND:
-                return TimeUnit.SECOND;
-            default:
-                throw new AssertionError(this);
-        }
-    }
-
-    public boolean isYearMonth() {
-        switch (this) {
-            case INTERVAL_YEAR:
-            case INTERVAL_YEAR_MONTH:
-            case INTERVAL_MONTH:
-                return true;
-            default:
-                return false;
-        }
-    }
-
-    /** Limit. */
-    public enum Limit {
-        ZERO,
-        UNDERFLOW,
-        OVERFLOW
-    }
-
-    private static @Nullable BigDecimal getNumericLimit(
-            int radix, int exponent, boolean sign, Limit limit, boolean beyond) {
-        switch (limit) {
-            case OVERFLOW:
-
-                // 2-based schemes run from -2^(N-1) to 2^(N-1)-1 e.g. -128 to +127
-                // 10-based schemas run from -(10^N-1) to 10^N-1 e.g. -99 to +99
-                final BigDecimal bigRadix = BigDecimal.valueOf(radix);
-                if (radix == 2) {
-                    --exponent;
-                }
-                BigDecimal decimal = bigRadix.pow(exponent);
-                if (sign || (radix != 2)) {
-                    decimal = decimal.subtract(BigDecimal.ONE);
-                }
-                if (beyond) {
-                    decimal = decimal.add(BigDecimal.ONE);
-                }
-                if (!sign) {
-                    decimal = decimal.negate();
-                }
-                return decimal;
-            case UNDERFLOW:
-                return beyond ? null : (sign ? BigDecimal.ONE : BigDecimal.ONE.negate());
-            case ZERO:
-                return BigDecimal.ZERO;
-            default:
-                throw Util.unexpected(limit);
-        }
-    }
-
-    public SqlLiteral createLiteral(Object o, SqlParserPos pos) {
-        switch (this) {
-            case BOOLEAN:
-                return SqlLiteral.createBoolean((Boolean) o, pos);
-            case TINYINT:
-            case SMALLINT:
-            case INTEGER:
-            case BIGINT:
-            case DECIMAL:
-                return SqlLiteral.createExactNumeric(o.toString(), pos);
-            case VARCHAR:
-            case CHAR:
-                return SqlLiteral.createCharString((String) o, pos);
-            case VARBINARY:
-            case BINARY:
-                return SqlLiteral.createBinaryString((byte[]) o, pos);
-            case DATE:
-                return SqlLiteral.createDate(
-                        o instanceof Calendar
-                                ? DateString.fromCalendarFields((Calendar) o)
-                                : (DateString) o,
-                        pos);
-            case TIME:
-                return SqlLiteral.createTime(
-                        o instanceof Calendar
-                                ? TimeString.fromCalendarFields((Calendar) o)
-                                : (TimeString) o,
-                        0 /* todo */,
-                        pos);
-            case TIMESTAMP:
-                return SqlLiteral.createTimestamp(
-                        this,
-                        o instanceof Calendar
-                                ? TimestampString.fromCalendarFields((Calendar) o)
-                                : (TimestampString) o,
-                        0 /* todo */,
-                        pos);
-            default:
-                throw Util.unexpected(this);
-        }
-    }
-
-    /** Returns the name of this type. */
-    public String getName() {
-        return name();
-    }
-
-    /**
-     * Returns the name of this type, with underscores converted to spaces, for example "TIMESTAMP
-     * WITH LOCAL TIME ZONE", "DATE".
-     */
-    public String getSpaceName() {
-        return name().replace('_', ' ');
-    }
-
-    /**
-     * Flags indicating precision/scale combinations.
-     *
-     * <p>Note: for intervals:
-     *
-     * <ul>
-     *   <li>precision = start (leading field) precision
-     *   <li>scale = fractional second precision
-     * </ul>
-     */
-    private interface PrecScale {
-        int NO_NO = 1;
-        int YES_NO = 2;
-        int YES_YES = 4;
-    }
-}
diff --git a/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java b/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
index a7a58c9958d51..696cdd5edcdae 100644
--- a/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
+++ b/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
@@ -67,6 +67,11 @@ public boolean isSortByAliasObscures() {
         return false;
     }
 
+    @Override
+    public boolean isSupportedDualTable() {
+        return SqlConformanceEnum.DEFAULT.isSupportedDualTable();
+    }
+
     @Override
     public boolean isFromRequired() {
         return false;
@@ -117,6 +122,11 @@ public boolean allowNiladicParentheses() {
         return true;
     }
 
+    @Override
+    public boolean allowNiladicConstantWithoutParentheses() {
+        return true;
+    }
+
     @Override
     public boolean allowExplicitRowValueConstructor() {
         return true;
@@ -172,6 +182,11 @@ public boolean allowLenientCoercion() {
         return SqlConformanceEnum.DEFAULT.allowLenientCoercion();
     }
 
+    @Override
+    public boolean checkedArithmetic() {
+        return SqlConformanceEnum.DEFAULT.checkedArithmetic();
+    }
+
     @Override
     public boolean isValueAllowed() {
         return true;
diff --git a/flink-table/flink-table-calcite-bridge/pom.xml b/flink-table/flink-table-calcite-bridge/pom.xml
index de1a516e2aff0..766524641010f 100644
--- a/flink-table/flink-table-calcite-bridge/pom.xml
+++ b/flink-table/flink-table-calcite-bridge/pom.xml
@@ -45,12 +45,12 @@ under the License.
 			<version>${calcite.version}</version>
 			<exclusions>
 				<!--
-				"mvn dependency:tree" as of Calcite 1.38.0:
-				[INFO] +- org.apache.calcite:calcite-core:jar:1.38.0:compile
-				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.38.0:compile
+				"mvn dependency:tree" as of Calcite 1.39.0:
+				[INFO] +- org.apache.calcite:calcite-core:jar:1.39.0:compile
+				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.39.0:compile
 				[INFO] |  +- org.locationtech.jts:jts-core:jar:1.19.0:compile
 				[INFO] |  +- com.fasterxml.jackson.core:jackson-annotations:jar:2.21:compile
-				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.25.0:compile
+				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.26.0:compile
 				[INFO] |  +- org.apiguardian:apiguardian-api:jar:1.1.2:compile
 				[INFO] |  +- com.fasterxml.jackson.core:jackson-core:jar:2.21.3:compile
 				[INFO] |  +- com.fasterxml.jackson.core:jackson-databind:jar:2.21.3:compile
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/jdbc/SimpleCalciteSchema.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/jdbc/SimpleCalciteSchema.java
index 864d50ef5c9b9..d04374dc546b8 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/jdbc/SimpleCalciteSchema.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/jdbc/SimpleCalciteSchema.java
@@ -133,38 +133,8 @@ public CalciteSchema add(String name, Schema schema) {
     }
 
     @Override
-    protected @Nullable CalciteSchema getImplicitSubSchema(
-            String schemaName, boolean caseSensitive) {
-        // Check implicit schemas.
-        final String schemaName2 =
-                caseSensitive
-                        ? schemaName
-                        : caseInsensitiveLookup(schema.getSubSchemaNames(), schemaName);
-        if (schemaName2 == null) {
-            return null;
-        }
-        final Schema s = schema.getSubSchema(schemaName2);
-        if (s == null) {
-            return null;
-        }
-        return new SimpleCalciteSchema(this, s, schemaName2);
-    }
-
-    @Override
-    protected @Nullable TableEntry getImplicitTable(String tableName, boolean caseSensitive) {
-        // Check implicit tables.
-        final String tableName2 =
-                caseSensitive
-                        ? tableName
-                        : caseInsensitiveLookup(schema.getTableNames(), tableName);
-        if (tableName2 == null) {
-            return null;
-        }
-        final Table table = schema.getTable(tableName2);
-        if (table == null) {
-            return null;
-        }
-        return tableEntry(tableName2, table);
+    protected CalciteSchema createSubSchema(Schema schema, String name) {
+        return new SimpleCalciteSchema(this, schema, name);
     }
 
     // ----- FLINK MODIFICATION START -----
@@ -201,28 +171,6 @@ public CalciteSchema add(String name, Schema schema) {
         return typeEntry(name2, type);
     }
 
-    @Override
-    protected void addImplicitSubSchemaToBuilder(
-            ImmutableSortedMap.Builder<String, CalciteSchema> builder) {
-        ImmutableSortedMap<String, CalciteSchema> explicitSubSchemas = builder.build();
-        for (String schemaName : schema.getSubSchemaNames()) {
-            if (explicitSubSchemas.containsKey(schemaName)) {
-                // explicit subschema wins.
-                continue;
-            }
-            Schema s = schema.getSubSchema(schemaName);
-            if (s != null) {
-                CalciteSchema calciteSchema = new SimpleCalciteSchema(this, s, schemaName);
-                builder.put(schemaName, calciteSchema);
-            }
-        }
-    }
-
-    @Override
-    protected void addImplicitTableToBuilder(ImmutableSortedSet.Builder<String> builder) {
-        builder.addAll(schema.getTableNames());
-    }
-
     @Override
     protected void addImplicitFunctionsToBuilder(
             ImmutableList.Builder<Function> builder, String name, boolean caseSensitive) {
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/plan/RelOptUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/plan/RelOptUtil.java
deleted file mode 100644
index 4cb6744d859b1..0000000000000
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/plan/RelOptUtil.java
+++ /dev/null
@@ -1,4596 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.plan;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.LinkedHashMultimap;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Multimap;
-import org.apache.calcite.adapter.enumerable.EnumerableRules;
-import org.apache.calcite.avatica.AvaticaConnection;
-import org.apache.calcite.config.CalciteSystemProperty;
-import org.apache.calcite.interpreter.Bindables;
-import org.apache.calcite.linq4j.Ord;
-import org.apache.calcite.linq4j.function.Experimental;
-import org.apache.calcite.rel.RelCollations;
-import org.apache.calcite.rel.RelHomogeneousShuttle;
-import org.apache.calcite.rel.RelNode;
-import org.apache.calcite.rel.RelShuttle;
-import org.apache.calcite.rel.RelVisitor;
-import org.apache.calcite.rel.RelWriter;
-import org.apache.calcite.rel.core.Aggregate;
-import org.apache.calcite.rel.core.AggregateCall;
-import org.apache.calcite.rel.core.Calc;
-import org.apache.calcite.rel.core.CorrelationId;
-import org.apache.calcite.rel.core.Filter;
-import org.apache.calcite.rel.core.Join;
-import org.apache.calcite.rel.core.JoinRelType;
-import org.apache.calcite.rel.core.Project;
-import org.apache.calcite.rel.core.RelFactories;
-import org.apache.calcite.rel.core.Sort;
-import org.apache.calcite.rel.core.TableScan;
-import org.apache.calcite.rel.externalize.RelDotWriter;
-import org.apache.calcite.rel.externalize.RelJsonWriter;
-import org.apache.calcite.rel.externalize.RelWriterImpl;
-import org.apache.calcite.rel.externalize.RelXmlWriter;
-import org.apache.calcite.rel.hint.HintStrategyTable;
-import org.apache.calcite.rel.hint.Hintable;
-import org.apache.calcite.rel.hint.RelHint;
-import org.apache.calcite.rel.logical.LogicalAggregate;
-import org.apache.calcite.rel.logical.LogicalAsofJoin;
-import org.apache.calcite.rel.logical.LogicalCalc;
-import org.apache.calcite.rel.logical.LogicalFilter;
-import org.apache.calcite.rel.logical.LogicalJoin;
-import org.apache.calcite.rel.logical.LogicalProject;
-import org.apache.calcite.rel.metadata.RelMetadataQuery;
-import org.apache.calcite.rel.rules.CoreRules;
-import org.apache.calcite.rel.rules.FilterProjectTransposeRule;
-import org.apache.calcite.rel.rules.MultiJoin;
-import org.apache.calcite.rel.rules.ProjectMergeRule;
-import org.apache.calcite.rel.stream.StreamRules;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.calcite.rel.type.RelDataTypeField;
-import org.apache.calcite.rel.type.RelDataTypeFieldImpl;
-import org.apache.calcite.rex.LogicVisitor;
-import org.apache.calcite.rex.RexBuilder;
-import org.apache.calcite.rex.RexCall;
-import org.apache.calcite.rex.RexCorrelVariable;
-import org.apache.calcite.rex.RexExecutor;
-import org.apache.calcite.rex.RexExecutorImpl;
-import org.apache.calcite.rex.RexFieldAccess;
-import org.apache.calcite.rex.RexInputRef;
-import org.apache.calcite.rex.RexLiteral;
-import org.apache.calcite.rex.RexLocalRef;
-import org.apache.calcite.rex.RexNode;
-import org.apache.calcite.rex.RexOver;
-import org.apache.calcite.rex.RexProgram;
-import org.apache.calcite.rex.RexShuttle;
-import org.apache.calcite.rex.RexSqlStandardConvertletTable;
-import org.apache.calcite.rex.RexSubQuery;
-import org.apache.calcite.rex.RexToSqlNodeConverter;
-import org.apache.calcite.rex.RexToSqlNodeConverterImpl;
-import org.apache.calcite.rex.RexUtil;
-import org.apache.calcite.rex.RexVisitorImpl;
-import org.apache.calcite.runtime.CalciteContextException;
-import org.apache.calcite.runtime.PairList;
-import org.apache.calcite.schema.ModifiableView;
-import org.apache.calcite.sql.SqlExplainFormat;
-import org.apache.calcite.sql.SqlExplainLevel;
-import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.SqlLiteral;
-import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.fun.SqlStdOperatorTable;
-import org.apache.calcite.sql.type.MultisetSqlType;
-import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.type.SqlTypeUtil;
-import org.apache.calcite.tools.RelBuilder;
-import org.apache.calcite.tools.RelBuilderFactory;
-import org.apache.calcite.util.ImmutableBitSet;
-import org.apache.calcite.util.Litmus;
-import org.apache.calcite.util.Pair;
-import org.apache.calcite.util.Permutation;
-import org.apache.calcite.util.Util;
-import org.apache.calcite.util.mapping.Mapping;
-import org.apache.calcite.util.mapping.MappingType;
-import org.apache.calcite.util.mapping.Mappings;
-import org.checkerframework.checker.initialization.qual.NotOnlyInitialized;
-import org.checkerframework.checker.initialization.qual.UnknownInitialization;
-import org.checkerframework.checker.nullness.qual.Nullable;
-import org.checkerframework.checker.nullness.qual.PolyNull;
-
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.util.AbstractList;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.BitSet;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.Deque;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.NavigableSet;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static java.util.Objects.requireNonNull;
-import static org.apache.calcite.rel.type.RelDataTypeImpl.NON_NULLABLE_SUFFIX;
-
-/**
- * <code>RelOptUtil</code> defines static utility methods for use in optimizing {@link RelNode}s.
- *
- * <p>FLINK modifications (backport of CALCITE-6764): Lines 2074 ~ 2106
- */
-public abstract class RelOptUtil {
-    // ~ Static fields/initializers ---------------------------------------------
-
-    public static final double EPSILON = 1.0e-5;
-
-    /**
-     * Default amount by which the complexity of a {@link Project} or {@link Filter} may increase
-     * when applying a rule. (Complexity is, roughly, the number of {@link RexNode}s in all
-     * expressions.)
-     *
-     * @see ProjectMergeRule.Config#bloat()
-     * @see FilterProjectTransposeRule.Config#bloat()
-     * @see RelBuilder.Config#bloat()
-     */
-    public static final int DEFAULT_BLOAT = 100;
-
-    @SuppressWarnings("Guava")
-    @Deprecated // to be removed before 2.0
-    public static final com.google.common.base.Predicate<Filter> FILTER_PREDICATE =
-            f -> !f.containsOver();
-
-    @SuppressWarnings("Guava")
-    @Deprecated // to be removed before 2.0
-    public static final com.google.common.base.Predicate<Project> PROJECT_PREDICATE =
-            RelOptUtil::notContainsWindowedAgg;
-
-    @SuppressWarnings("Guava")
-    @Deprecated // to be removed before 2.0
-    public static final com.google.common.base.Predicate<Calc> CALC_PREDICATE =
-            RelOptUtil::notContainsWindowedAgg;
-
-    // ~ Methods ----------------------------------------------------------------
-
-    /** Whether this node is a limit without sort specification. */
-    public static boolean isPureLimit(RelNode rel) {
-        return isLimit(rel) && !isOrder(rel);
-    }
-
-    /** Whether this node is a sort without limit specification. */
-    public static boolean isPureOrder(RelNode rel) {
-        return !isLimit(rel) && isOrder(rel);
-    }
-
-    /** Whether this node contains a limit specification. */
-    public static boolean isLimit(RelNode rel) {
-        return (rel instanceof Sort) && ((Sort) rel).fetch != null;
-    }
-
-    /** Whether this node contains a sort specification. */
-    public static boolean isOrder(RelNode rel) {
-        return (rel instanceof Sort) && !((Sort) rel).getCollation().getFieldCollations().isEmpty();
-    }
-
-    /** Whether this node contains a offset specification. */
-    public static boolean isOffset(RelNode rel) {
-        return (rel instanceof Sort) && ((Sort) rel).offset != null;
-    }
-
-    /** Returns a set of tables used by this expression or its children. */
-    public static Set<RelOptTable> findTables(RelNode rel) {
-        return new LinkedHashSet<>(findAllTables(rel));
-    }
-
-    /** Returns a list of all tables used by this expression or its children. */
-    public static List<RelOptTable> findAllTables(RelNode rel) {
-        final Multimap<Class<? extends RelNode>, RelNode> nodes =
-                rel.getCluster().getMetadataQuery().getNodeTypes(rel);
-        final List<RelOptTable> usedTables = new ArrayList<>();
-        if (nodes == null) {
-            return usedTables;
-        }
-        for (Map.Entry<Class<? extends RelNode>, Collection<RelNode>> e :
-                nodes.asMap().entrySet()) {
-            if (TableScan.class.isAssignableFrom(e.getKey())) {
-                for (RelNode node : e.getValue()) {
-                    TableScan scan = (TableScan) node;
-                    usedTables.add(scan.getTable());
-                }
-            }
-        }
-        return usedTables;
-    }
-
-    /** Returns a list of all table qualified names used by this expression or its children. */
-    public static List<String> findAllTableQualifiedNames(RelNode rel) {
-        return findAllTables(rel).stream()
-                .map(table -> table.getQualifiedName().toString())
-                .collect(Collectors.toList());
-    }
-
-    /** Returns a list of variables set by a relational expression or its descendants. */
-    public static Set<CorrelationId> getVariablesSet(RelNode rel) {
-        VariableSetVisitor visitor = new VariableSetVisitor();
-        go(visitor, rel);
-        return visitor.variables;
-    }
-
-    @Deprecated // to be removed before 2.0
-    @SuppressWarnings("MixedMutabilityReturnType")
-    public static List<CorrelationId> getVariablesSetAndUsed(RelNode rel0, RelNode rel1) {
-        Set<CorrelationId> set = getVariablesSet(rel0);
-        if (set.isEmpty()) {
-            return ImmutableList.of();
-        }
-        Set<CorrelationId> used = getVariablesUsed(rel1);
-        if (used.isEmpty()) {
-            return ImmutableList.of();
-        }
-        final List<CorrelationId> result = new ArrayList<>();
-        for (CorrelationId s : set) {
-            if (used.contains(s) && !result.contains(s)) {
-                result.add(s);
-            }
-        }
-        return result;
-    }
-
-    /**
-     * Returns the set of variables used by a relational expression or its descendants.
-     *
-     * <p>The set may contain "duplicates" (variables with different ids that, when resolved, will
-     * reference the same source relational expression).
-     *
-     * <p>The item type is the same as {@link org.apache.calcite.rex.RexCorrelVariable#id}.
-     */
-    public static Set<CorrelationId> getVariablesUsed(RelNode rel) {
-        CorrelationCollector visitor = new CorrelationCollector();
-        rel.accept(visitor);
-        return visitor.vuv.variables;
-    }
-
-    /**
-     * Returns the set of variables used by the given list of sub-queries and its descendants.
-     *
-     * @param subQueries The sub-queries containing correlation variables
-     * @return A list of correlation identifiers found within the sub-queries. The type of the
-     *     [CorrelationId] parameter corresponds to {@link
-     *     org.apache.calcite.rex.RexCorrelVariable#id}.
-     */
-    public static Set<CorrelationId> getVariablesUsed(List<RexSubQuery> subQueries) {
-        // Internally this function calls getVariablesUsed on a RelNode to get all the
-        // correlated variables in that RelNode
-        Set<CorrelationId> correlationIds = new HashSet<>();
-        for (RexSubQuery subQ : subQueries) {
-            correlationIds.addAll(getVariablesUsed(subQ.rel));
-        }
-        return correlationIds;
-    }
-
-    /** Finds which columns of a correlation variable are used within a relational expression. */
-    public static ImmutableBitSet correlationColumns(CorrelationId id, RelNode rel) {
-        final CorrelationCollector collector = new CorrelationCollector();
-        rel.accept(collector);
-        final ImmutableBitSet.Builder builder = ImmutableBitSet.builder();
-        for (int field : collector.vuv.variableFields.get(id)) {
-            if (field >= 0) {
-                builder.set(field);
-            }
-        }
-        return builder.build();
-    }
-
-    /**
-     * Returns true, and calls {@link Litmus#succeed()} if a given relational expression does not
-     * contain a given correlation.
-     */
-    public static boolean notContainsCorrelation(
-            RelNode r, CorrelationId correlationId, Litmus litmus) {
-        final Set<CorrelationId> set = getVariablesUsed(r);
-        if (!set.contains(correlationId)) {
-            return litmus.succeed();
-        } else {
-            return litmus.fail("contains {}", correlationId);
-        }
-    }
-
-    /** Sets a {@link RelVisitor} going on a given relational expression, and returns the result. */
-    public static void go(RelVisitor visitor, RelNode p) {
-        try {
-            visitor.go(p);
-        } catch (Exception e) {
-            throw new RuntimeException("while visiting tree", e);
-        }
-    }
-
-    /**
-     * Returns a list of the types of the fields in a given struct type. The list is immutable.
-     *
-     * @param type Struct type
-     * @return List of field types
-     * @see org.apache.calcite.rel.type.RelDataType#getFieldNames()
-     */
-    public static List<RelDataType> getFieldTypeList(final RelDataType type) {
-        return Util.transform(type.getFieldList(), RelDataTypeField::getType);
-    }
-
-    public static boolean areRowTypesEqual(
-            RelDataType rowType1, RelDataType rowType2, boolean compareNames) {
-        if (rowType1 == rowType2) {
-            return true;
-        }
-        if (compareNames) {
-            // if types are not identity-equal, then either the names or
-            // the types must be different
-            return false;
-        }
-        if (rowType2.getFieldCount() != rowType1.getFieldCount()) {
-            return false;
-        }
-        final List<RelDataTypeField> f1 = rowType1.getFieldList();
-        final List<RelDataTypeField> f2 = rowType2.getFieldList();
-        for (Pair<RelDataTypeField, RelDataTypeField> pair : Pair.zip(f1, f2)) {
-            final RelDataType type1 = pair.left.getType();
-            final RelDataType type2 = pair.right.getType();
-            // If one of the types is ANY comparison should succeed
-            if (type1.getSqlTypeName() == SqlTypeName.ANY
-                    || type2.getSqlTypeName() == SqlTypeName.ANY) {
-                continue;
-            }
-            if (!type1.equals(type2)) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Verifies that a row type being added to an equivalence class matches the existing type,
-     * raising an assertion if this is not the case.
-     *
-     * @param originalRel canonical rel for equivalence class
-     * @param newRel rel being added to equivalence class
-     * @param equivalenceClass object representing equivalence class
-     */
-    public static void verifyTypeEquivalence(
-            RelNode originalRel, RelNode newRel, Object equivalenceClass) {
-        RelDataType expectedRowType = originalRel.getRowType();
-        RelDataType actualRowType = newRel.getRowType();
-
-        // Row types must be the same, except for field names.
-        if (areRowTypesEqual(expectedRowType, actualRowType, false)) {
-            return;
-        }
-
-        String s =
-                "Cannot add expression of different type to set:\n"
-                        + "set type is "
-                        + expectedRowType.getFullTypeString()
-                        + "\nexpression type is "
-                        + actualRowType.getFullTypeString()
-                        + "\nset is "
-                        + equivalenceClass
-                        + "\nexpression is "
-                        + RelOptUtil.toString(newRel)
-                        + getFullTypeDifferenceString(
-                                "rowtype of original rel",
-                                expectedRowType,
-                                "rowtype of new rel",
-                                actualRowType);
-        throw new AssertionError(s);
-    }
-
-    /**
-     * Copy the {@link org.apache.calcite.rel.hint.RelHint}s from {@code originalRel} to {@code
-     * newRel} if both of them are {@link Hintable}.
-     *
-     * <p>The two relational expressions are assumed as semantically equivalent, that means the
-     * hints should be attached to the relational expression that expects to have them.
-     *
-     * <p>Try to propagate the hints to the first relational expression that matches, this is needed
-     * because many planner rules would generate a sub-tree whose root rel type is different with
-     * the original matched rel.
-     *
-     * <p>For the worst case, there is no relational expression that can apply these hints, and the
-     * whole sub-tree would be visited. We add a protection here: if the visiting depth is over than
-     * 3, just returns, because there are rare cases the new created sub-tree has layers bigger than
-     * that.
-     *
-     * <p>This is a best effort, we do not know exactly how the nodes are transformed in all kinds
-     * of planner rules, so for some complex relational expressions, the hints would very probably
-     * lost.
-     *
-     * <p>This function is experimental and would change without any notes.
-     *
-     * @param originalRel Original relational expression
-     * @param equiv New equivalent relational expression
-     * @return A copy of {@code newRel} with attached qualified hints from {@code originalRel}, or
-     *     {@code newRel} directly if one of them are not {@link Hintable}
-     */
-    @Experimental
-    public static RelNode propagateRelHints(RelNode originalRel, RelNode equiv) {
-        if (!(originalRel instanceof Hintable) || ((Hintable) originalRel).getHints().isEmpty()) {
-            return equiv;
-        }
-        final RelShuttle shuttle =
-                new SubTreeHintPropagateShuttle(
-                        originalRel.getCluster().getHintStrategies(),
-                        ((Hintable) originalRel).getHints());
-        return equiv.accept(shuttle);
-    }
-
-    /**
-     * Propagates the relational expression hints from root node to leaf node.
-     *
-     * @param rel The relational expression
-     * @param reset Flag saying if to reset the existing hints before the propagation
-     * @return New relational expression with hints propagated
-     */
-    public static RelNode propagateRelHints(RelNode rel, boolean reset) {
-        if (reset) {
-            rel = rel.accept(new ResetHintsShuttle());
-        }
-        final RelShuttle shuttle =
-                new RelHintPropagateShuttle(rel.getCluster().getHintStrategies());
-        return rel.accept(shuttle);
-    }
-
-    /**
-     * Copy the {@link org.apache.calcite.rel.hint.RelHint}s from {@code originalRel} to {@code
-     * newRel} if both of them are {@link Hintable}.
-     *
-     * <p>The hints would be attached directly(e.g. without any filtering).
-     *
-     * @param originalRel Original relational expression
-     * @param newRel New relational expression
-     * @return A copy of {@code newRel} with attached hints from {@code originalRel}, or {@code
-     *     newRel} directly if one of them are not {@link Hintable}
-     */
-    public static RelNode copyRelHints(RelNode originalRel, RelNode newRel) {
-        return copyRelHints(originalRel, newRel, false);
-    }
-
-    /**
-     * Copy the {@link org.apache.calcite.rel.hint.RelHint}s from {@code originalRel} to {@code
-     * newRel} if both of them are {@link Hintable}.
-     *
-     * <p>The hints would be filtered by the specified hint strategies if {@code filterHints} is
-     * true.
-     *
-     * @param originalRel Original relational expression
-     * @param newRel New relational expression
-     * @param filterHints Flag saying if to filter out unqualified hints for {@code newRel}
-     * @return A copy of {@code newRel} with attached hints from {@code originalRel}, or {@code
-     *     newRel} directly if one of them are not {@link Hintable}
-     */
-    public static RelNode copyRelHints(RelNode originalRel, RelNode newRel, boolean filterHints) {
-        if (originalRel == newRel && !filterHints) {
-            return originalRel;
-        }
-
-        if (originalRel instanceof Hintable
-                && newRel instanceof Hintable
-                && !((Hintable) originalRel).getHints().isEmpty()) {
-            final List<RelHint> hints = ((Hintable) originalRel).getHints();
-            if (filterHints) {
-                HintStrategyTable hintStrategies = originalRel.getCluster().getHintStrategies();
-                return ((Hintable) newRel).attachHints(hintStrategies.apply(hints, newRel));
-            } else {
-                // Keep all the hints if filterHints is false for 2 reasons:
-                // 1. Keep sync with the hints propagation logic,
-                // see RelHintPropagateShuttle for details.
-                // 2. We may re-propagate these hints when decorrelating a query.
-                return ((Hintable) newRel).attachHints(hints);
-            }
-        }
-        return newRel;
-    }
-
-    /**
-     * Returns a permutation describing where output fields come from. In the returned map, value of
-     * {@code map.getTargetOpt(i)} is {@code n} if field {@code i} projects input field {@code n} or
-     * applies a cast on {@code n}, -1 if it is another expression.
-     */
-    public static Mappings.TargetMapping permutationIgnoreCast(
-            List<RexNode> nodes, RelDataType inputRowType) {
-        final Mappings.TargetMapping mapping =
-                Mappings.create(
-                        MappingType.PARTIAL_FUNCTION, nodes.size(), inputRowType.getFieldCount());
-        for (Ord<RexNode> node : Ord.zip(nodes)) {
-            if (node.e instanceof RexInputRef) {
-                mapping.set(node.i, ((RexInputRef) node.e).getIndex());
-            } else if (node.e.isA(SqlKind.CAST)) {
-                final RexNode operand = ((RexCall) node.e).getOperands().get(0);
-                if (operand instanceof RexInputRef) {
-                    mapping.set(node.i, ((RexInputRef) operand).getIndex());
-                }
-            }
-        }
-        return mapping;
-    }
-
-    /**
-     * Returns a permutation describing where output fields come from. In the returned map, value of
-     * {@code map.getTargetOpt(i)} is {@code n} if field {@code i} projects input field {@code n},
-     * -1 if it is an expression.
-     */
-    public static Mappings.TargetMapping permutation(
-            List<RexNode> nodes, RelDataType inputRowType) {
-        final Mappings.TargetMapping mapping =
-                Mappings.create(
-                        MappingType.PARTIAL_FUNCTION, nodes.size(), inputRowType.getFieldCount());
-        for (Ord<RexNode> node : Ord.zip(nodes)) {
-            if (node.e instanceof RexInputRef) {
-                mapping.set(node.i, ((RexInputRef) node.e).getIndex());
-            }
-        }
-        return mapping;
-    }
-
-    /**
-     * Returns a permutation describing where the Project's fields come from after the Project is
-     * pushed down.
-     */
-    public static Mappings.TargetMapping permutationPushDownProject(
-            List<RexNode> nodes, RelDataType inputRowType, int sourceOffset, int targetOffset) {
-        final Mappings.TargetMapping mapping =
-                Mappings.create(
-                        MappingType.PARTIAL_FUNCTION,
-                        inputRowType.getFieldCount() + sourceOffset,
-                        nodes.size() + targetOffset);
-        for (Ord<RexNode> node : Ord.zip(nodes)) {
-            if (node.e instanceof RexInputRef) {
-                mapping.set(
-                        ((RexInputRef) node.e).getIndex() + sourceOffset, node.i + targetOffset);
-            }
-        }
-        return mapping;
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode createExistsPlan(
-            RelOptCluster cluster,
-            RelNode seekRel,
-            @Nullable List<RexNode> conditions,
-            @Nullable RexLiteral extraExpr,
-            @Nullable String extraName) {
-        assert extraExpr == null || extraName != null;
-        RelNode ret = seekRel;
-
-        if (conditions != null && !conditions.isEmpty()) {
-            RexNode conditionExp =
-                    RexUtil.composeConjunction(cluster.getRexBuilder(), conditions, true);
-
-            if (conditionExp != null) {
-                final RelFactories.FilterFactory factory = RelFactories.DEFAULT_FILTER_FACTORY;
-                ret = factory.createFilter(ret, conditionExp, ImmutableSet.of());
-            }
-        }
-
-        if (extraExpr != null) {
-            RexBuilder rexBuilder = cluster.getRexBuilder();
-
-            assert extraExpr == rexBuilder.makeLiteral(true);
-
-            // this should only be called for the exists case
-            // first stick an Agg on top of the sub-query
-            // agg does not like no agg functions so just pretend it is
-            // doing a min(TRUE)
-
-            final RelBuilder relBuilder = RelFactories.LOGICAL_BUILDER.create(cluster, null);
-            ret =
-                    relBuilder
-                            .push(ret)
-                            .project(extraExpr)
-                            .aggregate(
-                                    relBuilder.groupKey(),
-                                    relBuilder.min(relBuilder.field(0)).as(extraName))
-                            .build();
-        }
-
-        return ret;
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static Exists createExistsPlan(
-            RelNode seekRel, SubQueryType subQueryType, Logic logic, boolean notIn) {
-        final RelBuilder relBuilder =
-                RelFactories.LOGICAL_BUILDER.create(seekRel.getCluster(), null);
-        return createExistsPlan(seekRel, subQueryType, logic, notIn, relBuilder);
-    }
-
-    /**
-     * Creates a plan suitable for use in <code>EXISTS</code> or <code>IN</code> statements.
-     *
-     * @see org.apache.calcite.sql2rel.SqlToRelConverter SqlToRelConverter#convertExists
-     * @param seekRel A query rel, for example the resulting rel from 'select * from emp' or 'values
-     *     (1,2,3)' or '('Foo', 34)'.
-     * @param subQueryType Sub-query type
-     * @param logic Whether to use 2- or 3-valued boolean logic
-     * @param notIn Whether the operator is NOT IN
-     * @param relBuilder Builder for relational expressions
-     * @return A pair of a relational expression which outer joins a boolean condition column, and a
-     *     numeric offset. The offset is 2 if column 0 is the number of rows and column 1 is the
-     *     number of rows with not-null keys; 0 otherwise.
-     */
-    public static Exists createExistsPlan(
-            RelNode seekRel,
-            SubQueryType subQueryType,
-            Logic logic,
-            boolean notIn,
-            RelBuilder relBuilder) {
-        switch (subQueryType) {
-            case SCALAR:
-                return new Exists(seekRel, false, true);
-            default:
-                break;
-        }
-
-        switch (logic) {
-            case TRUE_FALSE_UNKNOWN:
-            case UNKNOWN_AS_TRUE:
-                if (notIn && !containsNullableFields(seekRel)) {
-                    logic = Logic.TRUE_FALSE;
-                }
-                break;
-            default:
-                break;
-        }
-        RelNode ret = seekRel;
-        final RelOptCluster cluster = seekRel.getCluster();
-        final RexBuilder rexBuilder = cluster.getRexBuilder();
-        final int keyCount = ret.getRowType().getFieldCount();
-        final boolean outerJoin = notIn || logic == RelOptUtil.Logic.TRUE_FALSE_UNKNOWN;
-        if (!outerJoin) {
-            final LogicalAggregate aggregate =
-                    LogicalAggregate.create(
-                            ret,
-                            ImmutableList.of(),
-                            ImmutableBitSet.range(keyCount),
-                            null,
-                            ImmutableList.of());
-            return new Exists(aggregate, false, false);
-        }
-
-        // for IN/NOT IN, it needs to output the fields
-        final List<RexNode> exprs = new ArrayList<>();
-        if (subQueryType == SubQueryType.IN) {
-            for (int i = 0; i < keyCount; i++) {
-                exprs.add(rexBuilder.makeInputRef(ret, i));
-            }
-        }
-
-        final int projectedKeyCount = exprs.size();
-        exprs.add(rexBuilder.makeLiteral(true));
-
-        ret =
-                relBuilder
-                        .push(ret)
-                        .project(exprs)
-                        .aggregate(
-                                relBuilder.groupKey(ImmutableBitSet.range(projectedKeyCount)),
-                                relBuilder.min(relBuilder.field(projectedKeyCount)))
-                        .build();
-
-        switch (logic) {
-            case TRUE_FALSE_UNKNOWN:
-            case UNKNOWN_AS_TRUE:
-                return new Exists(ret, true, true);
-            default:
-                return new Exists(ret, false, true);
-        }
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode createRenameRel(RelDataType outputType, RelNode rel) {
-        RelDataType inputType = rel.getRowType();
-        List<RelDataTypeField> inputFields = inputType.getFieldList();
-        int n = inputFields.size();
-
-        List<RelDataTypeField> outputFields = outputType.getFieldList();
-        assert outputFields.size() == n
-                : "rename: field count mismatch: in=" + inputType + ", out" + outputType;
-
-        final PairList<RexNode, String> renames = PairList.of();
-        final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
-        Pair.forEach(
-                inputFields,
-                outputFields,
-                (inputField, outputField) -> {
-                    assert inputField.getType().equals(outputField.getType());
-                    renames.add(
-                            rexBuilder.makeInputRef(inputField.getType(), inputField.getIndex()),
-                            outputField.getName());
-                });
-        final RelBuilder relBuilder = RelFactories.LOGICAL_BUILDER.create(rel.getCluster(), null);
-        return relBuilder.push(rel).project(renames.leftList(), renames.rightList(), true).build();
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode createFilter(RelNode child, RexNode condition) {
-        final RelFactories.FilterFactory factory = RelFactories.DEFAULT_FILTER_FACTORY;
-        return factory.createFilter(child, condition, ImmutableSet.of());
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode createFilter(
-            RelNode child, RexNode condition, RelFactories.FilterFactory filterFactory) {
-        return filterFactory.createFilter(child, condition, ImmutableSet.of());
-    }
-
-    /**
-     * Creates a filter, using the default filter factory, or returns the original relational
-     * expression if the condition is trivial.
-     */
-    public static RelNode createFilter(RelNode child, Iterable<? extends RexNode> conditions) {
-        return createFilter(child, conditions, RelFactories.DEFAULT_FILTER_FACTORY);
-    }
-
-    /**
-     * Creates a filter using the default factory, or returns the original relational expression if
-     * the condition is trivial.
-     */
-    public static RelNode createFilter(
-            RelNode child,
-            Iterable<? extends RexNode> conditions,
-            RelFactories.FilterFactory filterFactory) {
-        final RelOptCluster cluster = child.getCluster();
-        final RexNode condition =
-                RexUtil.composeConjunction(cluster.getRexBuilder(), conditions, true);
-        if (condition == null) {
-            return child;
-        } else {
-            return filterFactory.createFilter(child, condition, ImmutableSet.of());
-        }
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode createNullFilter(RelNode rel, Integer[] fieldOrdinals) {
-        RexNode condition = null;
-        final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
-        RelDataType rowType = rel.getRowType();
-        int n;
-        if (fieldOrdinals != null) {
-            n = fieldOrdinals.length;
-        } else {
-            n = rowType.getFieldCount();
-        }
-        List<RelDataTypeField> fields = rowType.getFieldList();
-        for (int i = 0; i < n; ++i) {
-            int iField;
-            if (fieldOrdinals != null) {
-                iField = fieldOrdinals[i];
-            } else {
-                iField = i;
-            }
-            RelDataType type = fields.get(iField).getType();
-            if (!type.isNullable()) {
-                continue;
-            }
-            RexNode newCondition =
-                    rexBuilder.makeCall(
-                            SqlStdOperatorTable.IS_NOT_NULL, rexBuilder.makeInputRef(type, iField));
-            if (condition == null) {
-                condition = newCondition;
-            } else {
-                condition = rexBuilder.makeCall(SqlStdOperatorTable.AND, condition, newCondition);
-            }
-        }
-        if (condition == null) {
-            // no filtering required
-            return rel;
-        }
-
-        final RelFactories.FilterFactory factory = RelFactories.DEFAULT_FILTER_FACTORY;
-        return factory.createFilter(rel, condition, ImmutableSet.of());
-    }
-
-    /**
-     * Creates a projection which casts a rel's output to a desired row type.
-     *
-     * <p>No need to create new projection if {@code rel} is already a project, instead, create a
-     * projection with the input of {@code rel} and the new cast expressions.
-     *
-     * <p>The desired row type and the row type to be converted must have the same number of fields.
-     *
-     * @param rel producer of rows to be converted
-     * @param castRowType row type after cast
-     * @param rename if true, use field names from castRowType; if false, preserve field names from
-     *     rel
-     * @return conversion rel
-     */
-    public static RelNode createCastRel(
-            final RelNode rel, RelDataType castRowType, boolean rename) {
-        return createCastRel(rel, castRowType, rename, RelFactories.DEFAULT_PROJECT_FACTORY);
-    }
-
-    /**
-     * Creates a projection which casts a rel's output to a desired row type.
-     *
-     * <p>No need to create new projection if {@code rel} is already a project, instead, create a
-     * projection with the input of {@code rel} and the new cast expressions.
-     *
-     * <p>The desired row type and the row type to be converted must have the same number of fields.
-     *
-     * @param rel producer of rows to be converted
-     * @param castRowType row type after cast
-     * @param rename if true, use field names from castRowType; if false, preserve field names from
-     *     rel
-     * @param projectFactory Project Factory
-     * @return conversion rel
-     */
-    public static RelNode createCastRel(
-            final RelNode rel,
-            RelDataType castRowType,
-            boolean rename,
-            RelFactories.ProjectFactory projectFactory) {
-        requireNonNull(projectFactory, "projectFactory");
-        RelDataType rowType = rel.getRowType();
-        if (areRowTypesEqual(rowType, castRowType, rename)) {
-            // nothing to do
-            return rel;
-        }
-        if (rowType.getFieldCount() != castRowType.getFieldCount()) {
-            throw new IllegalArgumentException(
-                    "Field counts are not equal: "
-                            + "rowType ["
-                            + rowType
-                            + "] castRowType ["
-                            + castRowType
-                            + "]");
-        }
-        final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
-        List<RexNode> castExps;
-        RelNode input;
-        List<RelHint> hints = ImmutableList.of();
-        Set<CorrelationId> correlationVariables;
-        if (rel instanceof Project) {
-            // No need to create another project node if the rel
-            // is already a project.
-            final Project project = (Project) rel;
-            castExps =
-                    RexUtil.generateCastExpressions(
-                            rexBuilder, castRowType, ((Project) rel).getProjects());
-            input = rel.getInput(0);
-            hints = project.getHints();
-            correlationVariables = project.getVariablesSet();
-        } else {
-            castExps = RexUtil.generateCastExpressions(rexBuilder, castRowType, rowType);
-            input = rel;
-            correlationVariables = ImmutableSet.of();
-        }
-        if (rename) {
-            // Use names and types from castRowType.
-            return projectFactory.createProject(
-                    input, hints, castExps, castRowType.getFieldNames(), correlationVariables);
-        } else {
-            // Use names from rowType, types from castRowType.
-            return projectFactory.createProject(
-                    input, hints, castExps, rowType.getFieldNames(), correlationVariables);
-        }
-    }
-
-    /** Gets all fields in an aggregate. */
-    public static Set<Integer> getAllFields(Aggregate aggregate) {
-        return getAllFields2(aggregate.getGroupSet(), aggregate.getAggCallList());
-    }
-
-    /** Gets all fields in an aggregate. */
-    public static Set<Integer> getAllFields2(
-            ImmutableBitSet groupSet, List<AggregateCall> aggCallList) {
-        final Set<Integer> allFields = new TreeSet<>(groupSet.asList());
-        for (AggregateCall aggregateCall : aggCallList) {
-            allFields.addAll(aggregateCall.getArgList());
-            if (aggregateCall.filterArg >= 0) {
-                allFields.add(aggregateCall.filterArg);
-            }
-            if (aggregateCall.distinctKeys != null) {
-                allFields.addAll(aggregateCall.distinctKeys.asList());
-            }
-            allFields.addAll(RelCollations.ordinals(aggregateCall.collation));
-        }
-        return allFields;
-    }
-
-    /**
-     * Creates a LogicalAggregate that removes all duplicates from the result of an underlying
-     * relational expression.
-     *
-     * @param rel underlying rel
-     * @return rel implementing SingleValueAgg
-     */
-    public static RelNode createSingleValueAggRel(RelOptCluster cluster, RelNode rel) {
-        final int aggCallCnt = rel.getRowType().getFieldCount();
-        final List<AggregateCall> aggCalls = new ArrayList<>();
-
-        for (int i = 0; i < aggCallCnt; i++) {
-            aggCalls.add(
-                    AggregateCall.create(
-                            SqlStdOperatorTable.SINGLE_VALUE,
-                            false,
-                            false,
-                            false,
-                            ImmutableList.of(),
-                            ImmutableList.of(i),
-                            -1,
-                            null,
-                            RelCollations.EMPTY,
-                            0,
-                            rel,
-                            null,
-                            null));
-        }
-
-        return LogicalAggregate.create(
-                rel, ImmutableList.of(), ImmutableBitSet.of(), null, aggCalls);
-    }
-
-    // CHECKSTYLE: IGNORE 1
-    /**
-     * @deprecated Use {@link RelBuilder#distinct()}.
-     */
-    @Deprecated // to be removed before 2.0
-    public static RelNode createDistinctRel(RelNode rel) {
-        return LogicalAggregate.create(
-                rel,
-                ImmutableList.of(),
-                ImmutableBitSet.range(rel.getRowType().getFieldCount()),
-                null,
-                ImmutableList.of());
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static boolean analyzeSimpleEquiJoin(LogicalJoin join, int[] joinFieldOrdinals) {
-        RexNode joinExp = join.getCondition();
-        if (joinExp.getKind() != SqlKind.EQUALS) {
-            return false;
-        }
-        RexCall binaryExpression = (RexCall) joinExp;
-        RexNode leftComparand = binaryExpression.operands.get(0);
-        RexNode rightComparand = binaryExpression.operands.get(1);
-        if (!(leftComparand instanceof RexInputRef)) {
-            return false;
-        }
-        if (!(rightComparand instanceof RexInputRef)) {
-            return false;
-        }
-
-        final int leftFieldCount = join.getLeft().getRowType().getFieldCount();
-        RexInputRef leftFieldAccess = (RexInputRef) leftComparand;
-        if (!(leftFieldAccess.getIndex() < leftFieldCount)) {
-            // left field must access left side of join
-            return false;
-        }
-
-        RexInputRef rightFieldAccess = (RexInputRef) rightComparand;
-        if (!(rightFieldAccess.getIndex() >= leftFieldCount)) {
-            // right field must access right side of join
-            return false;
-        }
-
-        joinFieldOrdinals[0] = leftFieldAccess.getIndex();
-        joinFieldOrdinals[1] = rightFieldAccess.getIndex() - leftFieldCount;
-        return true;
-    }
-
-    /**
-     * Splits out the equi-join components of a join condition, and returns what's left. For
-     * example, given the condition
-     *
-     * <blockquote>
-     *
-     * <code>L.A = R.X AND L.B = L.C AND (L.D = 5 OR L.E =
-     * R.Y)</code>
-     *
-     * </blockquote>
-     *
-     * <p>returns
-     *
-     * <ul>
-     *   <li>leftKeys = {A}
-     *   <li>rightKeys = {X}
-     *   <li>rest = L.B = L.C AND (L.D = 5 OR L.E = R.Y)
-     * </ul>
-     *
-     * @param left left input to join
-     * @param right right input to join
-     * @param condition join condition
-     * @param leftKeys The ordinals of the fields from the left input which are equi-join keys
-     * @param rightKeys The ordinals of the fields from the right input which are equi-join keys
-     * @param filterNulls List of boolean values for each join key position indicating whether the
-     *     operator filters out nulls or not. Value is true if the operator is EQUALS and false if
-     *     the operator is IS NOT DISTINCT FROM (or an expanded version). If <code>filterNulls
-     *     </code> is null, only join conditions with EQUALS operators are considered equi-join
-     *     components. Rest (including IS NOT DISTINCT FROM) are returned in remaining join
-     *     condition.
-     * @return remaining join filters that are not equijoins; may return a {@link RexLiteral} true,
-     *     but never null
-     */
-    public static RexNode splitJoinCondition(
-            RelNode left,
-            RelNode right,
-            RexNode condition,
-            List<Integer> leftKeys,
-            List<Integer> rightKeys,
-            @Nullable List<Boolean> filterNulls) {
-        final List<RexNode> nonEquiList = new ArrayList<>();
-
-        splitJoinCondition(left, right, condition, leftKeys, rightKeys, filterNulls, nonEquiList);
-
-        return RexUtil.composeConjunction(left.getCluster().getRexBuilder(), nonEquiList);
-    }
-
-    /**
-     * As {@link #splitJoinCondition(RelNode, RelNode, RexNode, List, List, List)}, but writes
-     * non-equi conditions to a conjunctive list.
-     */
-    public static void splitJoinCondition(
-            RelNode left,
-            RelNode right,
-            RexNode condition,
-            List<Integer> leftKeys,
-            List<Integer> rightKeys,
-            @Nullable List<Boolean> filterNulls,
-            List<RexNode> nonEquiList) {
-        splitJoinCondition(
-                left.getCluster().getRexBuilder(),
-                left.getRowType().getFieldCount(),
-                condition,
-                leftKeys,
-                rightKeys,
-                filterNulls,
-                nonEquiList);
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static boolean isEqui(RelNode left, RelNode right, RexNode condition) {
-        final List<Integer> leftKeys = new ArrayList<>();
-        final List<Integer> rightKeys = new ArrayList<>();
-        final List<Boolean> filterNulls = new ArrayList<>();
-        final List<RexNode> nonEquiList = new ArrayList<>();
-        splitJoinCondition(
-                left.getCluster().getRexBuilder(),
-                left.getRowType().getFieldCount(),
-                condition,
-                leftKeys,
-                rightKeys,
-                filterNulls,
-                nonEquiList);
-        return nonEquiList.isEmpty();
-    }
-
-    /**
-     * Splits out the equi-join (and optionally, a single non-equi) components of a join condition,
-     * and returns what's left. Projection might be required by the caller to provide join keys that
-     * are not direct field references.
-     *
-     * @param sysFieldList list of system fields
-     * @param leftRel left join input
-     * @param rightRel right join input
-     * @param condition join condition
-     * @param leftJoinKeys The join keys from the left input which are equi-join keys
-     * @param rightJoinKeys The join keys from the right input which are equi-join keys
-     * @param filterNulls The join key positions for which null values will not match. null values
-     *     only match for the "is not distinct from" condition.
-     * @param rangeOp if null, only locate equi-joins; otherwise, locate a single non-equi join
-     *     predicate and return its operator in this list; join keys associated with the non-equi
-     *     join predicate are at the end of the key lists returned
-     * @return What's left, never null
-     */
-    public static RexNode splitJoinCondition(
-            List<RelDataTypeField> sysFieldList,
-            RelNode leftRel,
-            RelNode rightRel,
-            RexNode condition,
-            List<RexNode> leftJoinKeys,
-            List<RexNode> rightJoinKeys,
-            @Nullable List<Integer> filterNulls,
-            @Nullable List<SqlOperator> rangeOp) {
-        return splitJoinCondition(
-                sysFieldList,
-                ImmutableList.of(leftRel, rightRel),
-                condition,
-                ImmutableList.of(leftJoinKeys, rightJoinKeys),
-                filterNulls,
-                rangeOp);
-    }
-
-    /**
-     * Splits out the equi-join (and optionally, a single non-equi) components of a join condition,
-     * and returns what's left. Projection might be required by the caller to provide join keys that
-     * are not direct field references.
-     *
-     * @param sysFieldList list of system fields
-     * @param inputs join inputs
-     * @param condition join condition
-     * @param joinKeys The join keys from the inputs which are equi-join keys
-     * @param filterNulls The join key positions for which null values will not match. null values
-     *     only match for the "is not distinct from" condition.
-     * @param rangeOp if null, only locate equi-joins; otherwise, locate a single non-equi join
-     *     predicate and return its operator in this list; join keys associated with the non-equi
-     *     join predicate are at the end of the key lists returned
-     * @return What's left, never null
-     */
-    public static RexNode splitJoinCondition(
-            List<RelDataTypeField> sysFieldList,
-            List<RelNode> inputs,
-            RexNode condition,
-            List<List<RexNode>> joinKeys,
-            @Nullable List<Integer> filterNulls,
-            @Nullable List<SqlOperator> rangeOp) {
-        final List<RexNode> nonEquiList = new ArrayList<>();
-
-        splitJoinCondition(
-                sysFieldList, inputs, condition, joinKeys, filterNulls, rangeOp, nonEquiList);
-
-        // Convert the remainders into a list that are AND'ed together.
-        return RexUtil.composeConjunction(inputs.get(0).getCluster().getRexBuilder(), nonEquiList);
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static @Nullable RexNode splitCorrelatedFilterCondition(
-            LogicalFilter filter, List<RexInputRef> joinKeys, List<RexNode> correlatedJoinKeys) {
-        final List<RexNode> nonEquiList = new ArrayList<>();
-
-        splitCorrelatedFilterCondition(
-                filter, filter.getCondition(), joinKeys, correlatedJoinKeys, nonEquiList);
-
-        // Convert the remainders into a list that are AND'ed together.
-        return RexUtil.composeConjunction(filter.getCluster().getRexBuilder(), nonEquiList, true);
-    }
-
-    public static @Nullable RexNode splitCorrelatedFilterCondition(
-            LogicalFilter filter,
-            List<RexNode> joinKeys,
-            List<RexNode> correlatedJoinKeys,
-            boolean extractCorrelatedFieldAccess) {
-        return splitCorrelatedFilterCondition(
-                (Filter) filter, joinKeys, correlatedJoinKeys, extractCorrelatedFieldAccess);
-    }
-
-    public static @Nullable RexNode splitCorrelatedFilterCondition(
-            Filter filter,
-            List<RexNode> joinKeys,
-            List<RexNode> correlatedJoinKeys,
-            boolean extractCorrelatedFieldAccess) {
-        final List<RexNode> nonEquiList = new ArrayList<>();
-
-        splitCorrelatedFilterCondition(
-                filter,
-                filter.getCondition(),
-                joinKeys,
-                correlatedJoinKeys,
-                nonEquiList,
-                extractCorrelatedFieldAccess);
-
-        // Convert the remainders into a list that are AND'ed together.
-        return RexUtil.composeConjunction(filter.getCluster().getRexBuilder(), nonEquiList, true);
-    }
-
-    private static void splitJoinCondition(
-            List<RelDataTypeField> sysFieldList,
-            List<RelNode> inputs,
-            RexNode condition,
-            List<List<RexNode>> joinKeys,
-            @Nullable List<Integer> filterNulls,
-            @Nullable List<SqlOperator> rangeOp,
-            List<RexNode> nonEquiList) {
-        final int sysFieldCount = sysFieldList.size();
-        final RelOptCluster cluster = inputs.get(0).getCluster();
-        final RexBuilder rexBuilder = cluster.getRexBuilder();
-        final RelDataTypeFactory typeFactory = cluster.getTypeFactory();
-
-        final ImmutableBitSet[] inputsRange = new ImmutableBitSet[inputs.size()];
-        int totalFieldCount = 0;
-        for (int i = 0; i < inputs.size(); i++) {
-            final int firstField = totalFieldCount + sysFieldCount;
-            totalFieldCount = firstField + inputs.get(i).getRowType().getFieldCount();
-            inputsRange[i] = ImmutableBitSet.range(firstField, totalFieldCount);
-        }
-
-        // adjustment array
-        int[] adjustments = new int[totalFieldCount];
-        for (int i = 0; i < inputs.size(); i++) {
-            final int adjustment = inputsRange[i].nextSetBit(0);
-            for (int j = adjustment; j < inputsRange[i].length(); j++) {
-                adjustments[j] = -adjustment;
-            }
-        }
-
-        if (condition.getKind() == SqlKind.AND) {
-            for (RexNode operand : ((RexCall) condition).getOperands()) {
-                splitJoinCondition(
-                        sysFieldList, inputs, operand, joinKeys, filterNulls, rangeOp, nonEquiList);
-            }
-            return;
-        }
-
-        if (condition instanceof RexCall) {
-            RexNode leftKey = null;
-            RexNode rightKey = null;
-            int leftInput = 0;
-            int rightInput = 0;
-            List<RelDataTypeField> leftFields = null;
-            List<RelDataTypeField> rightFields = null;
-            boolean reverse = false;
-
-            final RexCall call =
-                    collapseExpandedIsNotDistinctFromExpr((RexCall) condition, rexBuilder);
-            SqlKind kind = call.getKind();
-
-            // Only consider range operators if we haven't already seen one
-            if ((kind == SqlKind.EQUALS)
-                    || (filterNulls != null && kind == SqlKind.IS_NOT_DISTINCT_FROM)
-                    || (rangeOp != null
-                            && rangeOp.isEmpty()
-                            && (kind == SqlKind.GREATER_THAN
-                                    || kind == SqlKind.GREATER_THAN_OR_EQUAL
-                                    || kind == SqlKind.LESS_THAN
-                                    || kind == SqlKind.LESS_THAN_OR_EQUAL))) {
-                final List<RexNode> operands = call.getOperands();
-                RexNode op0 = operands.get(0);
-                RexNode op1 = operands.get(1);
-
-                final ImmutableBitSet projRefs0 = InputFinder.bits(op0);
-                final ImmutableBitSet projRefs1 = InputFinder.bits(op1);
-
-                boolean foundBothInputs = false;
-                for (int i = 0; i < inputs.size() && !foundBothInputs; i++) {
-                    if (projRefs0.intersects(inputsRange[i])
-                            && projRefs0.union(inputsRange[i]).equals(inputsRange[i])) {
-                        if (leftKey == null) {
-                            leftKey = op0;
-                            leftInput = i;
-                            leftFields = inputs.get(leftInput).getRowType().getFieldList();
-                        } else {
-                            rightKey = op0;
-                            rightInput = i;
-                            rightFields = inputs.get(rightInput).getRowType().getFieldList();
-                            reverse = true;
-                            foundBothInputs = true;
-                        }
-                    } else if (projRefs1.intersects(inputsRange[i])
-                            && projRefs1.union(inputsRange[i]).equals(inputsRange[i])) {
-                        if (leftKey == null) {
-                            leftKey = op1;
-                            leftInput = i;
-                            leftFields = inputs.get(leftInput).getRowType().getFieldList();
-                        } else {
-                            rightKey = op1;
-                            rightInput = i;
-                            rightFields = inputs.get(rightInput).getRowType().getFieldList();
-                            foundBothInputs = true;
-                        }
-                    }
-                }
-
-                if ((leftKey != null) && (rightKey != null)) {
-                    // replace right Key input ref
-                    rightKey =
-                            rightKey.accept(
-                                    new RelOptUtil.RexInputConverter(
-                                            rexBuilder, rightFields, rightFields, adjustments));
-
-                    // left key only needs to be adjusted if there are system
-                    // fields, but do it for uniformity
-                    leftKey =
-                            leftKey.accept(
-                                    new RelOptUtil.RexInputConverter(
-                                            rexBuilder, leftFields, leftFields, adjustments));
-
-                    RelDataType leftKeyType = leftKey.getType();
-                    RelDataType rightKeyType = rightKey.getType();
-
-                    if (leftKeyType != rightKeyType) {
-                        // perform casting
-                        RelDataType targetKeyType =
-                                typeFactory.leastRestrictive(
-                                        ImmutableList.of(leftKeyType, rightKeyType));
-
-                        if (targetKeyType == null) {
-                            throw new AssertionError(
-                                    "Cannot find common type for join keys "
-                                            + leftKey
-                                            + " (type "
-                                            + leftKeyType
-                                            + ") and "
-                                            + rightKey
-                                            + " (type "
-                                            + rightKeyType
-                                            + ")");
-                        }
-
-                        if (leftKeyType != targetKeyType) {
-                            leftKey = rexBuilder.makeCast(targetKeyType, leftKey);
-                        }
-
-                        if (rightKeyType != targetKeyType) {
-                            rightKey = rexBuilder.makeCast(targetKeyType, rightKey);
-                        }
-                    }
-                }
-            }
-
-            if ((leftKey != null) && (rightKey != null)) {
-                // found suitable join keys
-                // add them to key list, ensuring that if there is a
-                // non-equi join predicate, it appears at the end of the
-                // key list; also mark the null filtering property
-                addJoinKey(
-                        joinKeys.get(leftInput), leftKey, (rangeOp != null) && !rangeOp.isEmpty());
-                addJoinKey(
-                        joinKeys.get(rightInput),
-                        rightKey,
-                        (rangeOp != null) && !rangeOp.isEmpty());
-                if (filterNulls != null && kind == SqlKind.EQUALS) {
-                    // nulls are considered not matching for equality comparison
-                    // add the position of the most recently inserted key
-                    filterNulls.add(joinKeys.get(leftInput).size() - 1);
-                }
-                if (rangeOp != null && kind != SqlKind.EQUALS && kind != SqlKind.IS_DISTINCT_FROM) {
-                    SqlOperator op = call.getOperator();
-                    if (reverse) {
-                        op = requireNonNull(op.reverse());
-                    }
-                    rangeOp.add(op);
-                }
-                return;
-            } // else fall through and add this condition as nonEqui condition
-        }
-
-        // The operator is not of RexCall type
-        // So we fail. Fall through.
-        // Add this condition to the list of non-equi-join conditions.
-        nonEquiList.add(condition);
-    }
-
-    /** Builds an equi-join condition from a set of left and right keys. */
-    public static RexNode createEquiJoinCondition(
-            final RelNode left,
-            final List<Integer> leftKeys,
-            final RelNode right,
-            final List<Integer> rightKeys,
-            final RexBuilder rexBuilder) {
-        final List<RelDataType> leftTypes = RelOptUtil.getFieldTypeList(left.getRowType());
-        final List<RelDataType> rightTypes = RelOptUtil.getFieldTypeList(right.getRowType());
-        return RexUtil.composeConjunction(
-                rexBuilder,
-                new AbstractList<RexNode>() {
-                    @Override
-                    public RexNode get(int index) {
-                        final int leftKey = leftKeys.get(index);
-                        final int rightKey = rightKeys.get(index);
-                        return rexBuilder.makeCall(
-                                SqlStdOperatorTable.EQUALS,
-                                rexBuilder.makeInputRef(leftTypes.get(leftKey), leftKey),
-                                rexBuilder.makeInputRef(
-                                        rightTypes.get(rightKey), leftTypes.size() + rightKey));
-                    }
-
-                    @Override
-                    public int size() {
-                        return leftKeys.size();
-                    }
-                });
-    }
-
-    /**
-     * Returns {@link SqlOperator} for given {@link SqlKind} or returns {@code operator} when {@link
-     * SqlKind} is not known.
-     *
-     * @param kind input kind
-     * @param operator default operator value
-     * @return SqlOperator for the given kind
-     * @see RexUtil#op(SqlKind)
-     */
-    public static SqlOperator op(SqlKind kind, SqlOperator operator) {
-        switch (kind) {
-            case EQUALS:
-                return SqlStdOperatorTable.EQUALS;
-            case NOT_EQUALS:
-                return SqlStdOperatorTable.NOT_EQUALS;
-            case GREATER_THAN:
-                return SqlStdOperatorTable.GREATER_THAN;
-            case GREATER_THAN_OR_EQUAL:
-                return SqlStdOperatorTable.GREATER_THAN_OR_EQUAL;
-            case LESS_THAN:
-                return SqlStdOperatorTable.LESS_THAN;
-            case LESS_THAN_OR_EQUAL:
-                return SqlStdOperatorTable.LESS_THAN_OR_EQUAL;
-            case IS_DISTINCT_FROM:
-                return SqlStdOperatorTable.IS_DISTINCT_FROM;
-            case IS_NOT_DISTINCT_FROM:
-                return SqlStdOperatorTable.IS_NOT_DISTINCT_FROM;
-            default:
-                return operator;
-        }
-    }
-
-    private static void addJoinKey(
-            List<RexNode> joinKeyList, RexNode key, boolean preserveLastElementInList) {
-        if (!joinKeyList.isEmpty() && preserveLastElementInList) {
-            joinKeyList.add(joinKeyList.size() - 1, key);
-        } else {
-            joinKeyList.add(key);
-        }
-    }
-
-    private static void splitCorrelatedFilterCondition(
-            LogicalFilter filter,
-            RexNode condition,
-            List<RexInputRef> joinKeys,
-            List<RexNode> correlatedJoinKeys,
-            List<RexNode> nonEquiList) {
-        if (condition instanceof RexCall) {
-            RexCall call = (RexCall) condition;
-            if (call.getOperator().getKind() == SqlKind.AND) {
-                for (RexNode operand : call.getOperands()) {
-                    splitCorrelatedFilterCondition(
-                            filter, operand, joinKeys, correlatedJoinKeys, nonEquiList);
-                }
-                return;
-            }
-
-            if (call.getOperator().getKind() == SqlKind.EQUALS) {
-                final List<RexNode> operands = call.getOperands();
-                RexNode op0 = operands.get(0);
-                RexNode op1 = operands.get(1);
-
-                if (!RexUtil.containsInputRef(op0) && op1 instanceof RexInputRef) {
-                    correlatedJoinKeys.add(op0);
-                    joinKeys.add((RexInputRef) op1);
-                    return;
-                } else if (op0 instanceof RexInputRef && !RexUtil.containsInputRef(op1)) {
-                    joinKeys.add((RexInputRef) op0);
-                    correlatedJoinKeys.add(op1);
-                    return;
-                }
-            }
-        }
-
-        // The operator is not of RexCall type
-        // So we fail. Fall through.
-        // Add this condition to the list of non-equi-join conditions.
-        nonEquiList.add(condition);
-    }
-
-    @SuppressWarnings("unused")
-    private static void splitCorrelatedFilterCondition(
-            LogicalFilter filter,
-            RexNode condition,
-            List<RexNode> joinKeys,
-            List<RexNode> correlatedJoinKeys,
-            List<RexNode> nonEquiList,
-            boolean extractCorrelatedFieldAccess) {
-        splitCorrelatedFilterCondition(
-                (Filter) filter,
-                condition,
-                joinKeys,
-                correlatedJoinKeys,
-                nonEquiList,
-                extractCorrelatedFieldAccess);
-    }
-
-    private static void splitCorrelatedFilterCondition(
-            Filter filter,
-            RexNode condition,
-            List<RexNode> joinKeys,
-            List<RexNode> correlatedJoinKeys,
-            List<RexNode> nonEquiList,
-            boolean extractCorrelatedFieldAccess) {
-        if (condition instanceof RexCall) {
-            RexCall call = (RexCall) condition;
-            if (call.getOperator().getKind() == SqlKind.AND) {
-                for (RexNode operand : call.getOperands()) {
-                    splitCorrelatedFilterCondition(
-                            filter,
-                            operand,
-                            joinKeys,
-                            correlatedJoinKeys,
-                            nonEquiList,
-                            extractCorrelatedFieldAccess);
-                }
-                return;
-            }
-
-            if (call.getOperator().getKind() == SqlKind.EQUALS) {
-                final List<RexNode> operands = call.getOperands();
-                RexNode op0 = operands.get(0);
-                RexNode op1 = operands.get(1);
-
-                if (extractCorrelatedFieldAccess) {
-                    if (!RexUtil.containsFieldAccess(op0) && op1 instanceof RexFieldAccess) {
-                        joinKeys.add(op0);
-                        correlatedJoinKeys.add(op1);
-                        return;
-                    } else if (op0 instanceof RexFieldAccess && !RexUtil.containsFieldAccess(op1)) {
-                        correlatedJoinKeys.add(op0);
-                        joinKeys.add(op1);
-                        return;
-                    }
-                } else {
-                    if (!RexUtil.containsInputRef(op0) && op1 instanceof RexInputRef) {
-                        correlatedJoinKeys.add(op0);
-                        joinKeys.add(op1);
-                        return;
-                    } else if (op0 instanceof RexInputRef && !RexUtil.containsInputRef(op1)) {
-                        joinKeys.add(op0);
-                        correlatedJoinKeys.add(op1);
-                        return;
-                    }
-                }
-            }
-        }
-
-        // The operator is not of RexCall type
-        // So we fail. Fall through.
-        // Add this condition to the list of non-equi-join conditions.
-        nonEquiList.add(condition);
-    }
-
-    private static void splitJoinCondition(
-            final RexBuilder rexBuilder,
-            final int leftFieldCount,
-            RexNode condition,
-            List<Integer> leftKeys,
-            List<Integer> rightKeys,
-            @Nullable List<Boolean> filterNulls,
-            List<RexNode> nonEquiList) {
-        if (condition instanceof RexCall) {
-            RexCall call = (RexCall) condition;
-            SqlKind kind = call.getKind();
-            if (kind == SqlKind.AND) {
-                for (RexNode operand : call.getOperands()) {
-                    splitJoinCondition(
-                            rexBuilder,
-                            leftFieldCount,
-                            operand,
-                            leftKeys,
-                            rightKeys,
-                            filterNulls,
-                            nonEquiList);
-                }
-                return;
-            }
-
-            if (filterNulls != null) {
-                call = collapseExpandedIsNotDistinctFromExpr(call, rexBuilder);
-                kind = call.getKind();
-            }
-
-            // "=" and "IS NOT DISTINCT FROM" are the same except for how they
-            // treat nulls.
-            if (kind == SqlKind.EQUALS
-                    || (filterNulls != null && kind == SqlKind.IS_NOT_DISTINCT_FROM)) {
-                final List<RexNode> operands = call.getOperands();
-                if ((operands.get(0) instanceof RexInputRef)
-                        && (operands.get(1) instanceof RexInputRef)) {
-                    RexInputRef op0 = (RexInputRef) operands.get(0);
-                    RexInputRef op1 = (RexInputRef) operands.get(1);
-
-                    RexInputRef leftField;
-                    RexInputRef rightField;
-                    if ((op0.getIndex() < leftFieldCount) && (op1.getIndex() >= leftFieldCount)) {
-                        // Arguments were of form 'op0 = op1'
-                        leftField = op0;
-                        rightField = op1;
-                    } else if ((op1.getIndex() < leftFieldCount)
-                            && (op0.getIndex() >= leftFieldCount)) {
-                        // Arguments were of form 'op1 = op0'
-                        leftField = op1;
-                        rightField = op0;
-                    } else {
-                        nonEquiList.add(condition);
-                        return;
-                    }
-
-                    leftKeys.add(leftField.getIndex());
-                    rightKeys.add(rightField.getIndex() - leftFieldCount);
-                    if (filterNulls != null) {
-                        filterNulls.add(kind == SqlKind.EQUALS);
-                    }
-                    return;
-                }
-                // Arguments were not field references, one from each side, so
-                // we fail. Fall through.
-            }
-        }
-
-        // Add this condition to the list of non-equi-join conditions.
-        if (!condition.isAlwaysTrue()) {
-            nonEquiList.add(condition);
-        }
-    }
-
-    /**
-     * Collapses an expanded version of {@code IS NOT DISTINCT FROM} expression.
-     *
-     * <p>Helper method for {@link #splitJoinCondition(RexBuilder, int, RexNode, List, List, List,
-     * List)} and {@link #splitJoinCondition(List, List, RexNode, List, List, List, List)}.
-     *
-     * <p>If the given expr <code>call</code> is an expanded version of {@code IS NOT DISTINCT FROM}
-     * function call, collapses it and return a {@code IS NOT DISTINCT FROM} function call.
-     *
-     * <p>For example: {@code t1.key IS NOT DISTINCT FROM t2.key} can rewritten in expanded form as
-     * {@code t1.key = t2.key OR (t1.key IS NULL AND t2.key IS NULL)}.
-     *
-     * @param call Function expression to try collapsing
-     * @param rexBuilder {@link RexBuilder} instance to create new {@link RexCall} instances.
-     * @return If the given function is an expanded IS NOT DISTINCT FROM function call, return a IS
-     *     NOT DISTINCT FROM function call. Otherwise return the input function call as it is.
-     */
-    public static RexCall collapseExpandedIsNotDistinctFromExpr(
-            final RexCall call, final RexBuilder rexBuilder) {
-        switch (call.getKind()) {
-            case OR:
-                return doCollapseExpandedIsNotDistinctFromOrExpr(call, rexBuilder);
-
-            case CASE:
-                return doCollapseExpandedIsNotDistinctFromCaseExpr(call, rexBuilder);
-
-            default:
-                return call;
-        }
-    }
-
-    private static RexCall doCollapseExpandedIsNotDistinctFromOrExpr(
-            final RexCall call, final RexBuilder rexBuilder) {
-        if (call.getKind() != SqlKind.OR || call.getOperands().size() != 2) {
-            return call;
-        }
-
-        final RexNode op0 = call.getOperands().get(0);
-        final RexNode op1 = call.getOperands().get(1);
-
-        if (!(op0 instanceof RexCall) || !(op1 instanceof RexCall)) {
-            return call;
-        }
-
-        RexCall opEqCall = (RexCall) op0;
-        RexCall opNullEqCall = (RexCall) op1;
-
-        // Swapping the operands if necessary
-        if (opEqCall.getKind() == SqlKind.AND
-                && (opNullEqCall.getKind() == SqlKind.EQUALS
-                        || opNullEqCall.getKind() == SqlKind.IS_TRUE)) {
-            RexCall temp = opEqCall;
-            opEqCall = opNullEqCall;
-            opNullEqCall = temp;
-        }
-
-        // Check if EQUALS is actually wrapped in IS TRUE expression
-        if (opEqCall.getKind() == SqlKind.IS_TRUE) {
-            RexNode tmp = opEqCall.getOperands().get(0);
-            if (!(tmp instanceof RexCall)) {
-                return call;
-            }
-            opEqCall = (RexCall) tmp;
-        }
-
-        if (opNullEqCall.getKind() != SqlKind.AND
-                || opNullEqCall.getOperands().size() != 2
-                || opEqCall.getKind() != SqlKind.EQUALS) {
-            return call;
-        }
-
-        final RexNode op10 = opNullEqCall.getOperands().get(0);
-        final RexNode op11 = opNullEqCall.getOperands().get(1);
-        if (op10.getKind() != SqlKind.IS_NULL || op11.getKind() != SqlKind.IS_NULL) {
-            return call;
-        }
-
-        return doCollapseExpandedIsNotDistinctFrom(
-                rexBuilder, call, (RexCall) op10, (RexCall) op11, opEqCall);
-    }
-
-    private static RexCall doCollapseExpandedIsNotDistinctFromCaseExpr(
-            final RexCall call, final RexBuilder rexBuilder) {
-        if (call.getKind() != SqlKind.CASE || call.getOperands().size() != 5) {
-            return call;
-        }
-
-        final RexNode op0 = call.getOperands().get(0);
-        final RexNode op1 = call.getOperands().get(1);
-        final RexNode op2 = call.getOperands().get(2);
-        final RexNode op3 = call.getOperands().get(3);
-        final RexNode op4 = call.getOperands().get(4);
-
-        if (!(op0 instanceof RexCall)
-                || !(op1 instanceof RexCall)
-                || !(op2 instanceof RexCall)
-                || !(op3 instanceof RexCall)
-                || !(op4 instanceof RexCall)) {
-            return call;
-        }
-
-        RexCall ifCall = (RexCall) op0;
-        RexCall thenCall = (RexCall) op1;
-        RexCall elseIfCall = (RexCall) op2;
-        RexCall elseIfThenCall = (RexCall) op3;
-        RexCall elseCall = (RexCall) op4;
-
-        if (ifCall.getKind() != SqlKind.IS_NULL
-                || thenCall.getKind() != SqlKind.IS_NULL
-                || elseIfCall.getKind() != SqlKind.IS_NULL
-                || elseIfThenCall.getKind() != SqlKind.IS_NULL
-                || elseCall.getKind() != SqlKind.EQUALS) {
-            return call;
-        }
-
-        if (!ifCall.equals(elseIfThenCall) || !thenCall.equals(elseIfCall)) {
-            return call;
-        }
-
-        return doCollapseExpandedIsNotDistinctFrom(rexBuilder, call, ifCall, elseIfCall, elseCall);
-    }
-
-    private static RexCall doCollapseExpandedIsNotDistinctFrom(
-            final RexBuilder rexBuilder,
-            final RexCall call,
-            RexCall ifNull0Call,
-            RexCall ifNull1Call,
-            RexCall equalsCall) {
-        final RexNode isNullInput0 = ifNull0Call.getOperands().get(0);
-        final RexNode isNullInput1 = ifNull1Call.getOperands().get(0);
-
-        final RexNode equalsInput0 =
-                RexUtil.removeNullabilityCast(
-                        rexBuilder.getTypeFactory(), equalsCall.getOperands().get(0));
-        final RexNode equalsInput1 =
-                RexUtil.removeNullabilityCast(
-                        rexBuilder.getTypeFactory(), equalsCall.getOperands().get(1));
-
-        if ((isNullInput0.equals(equalsInput0) && isNullInput1.equals(equalsInput1))
-                || (isNullInput1.equals(equalsInput0) && isNullInput0.equals(equalsInput1))) {
-            return (RexCall)
-                    rexBuilder.makeCall(
-                            SqlStdOperatorTable.IS_NOT_DISTINCT_FROM,
-                            ImmutableList.of(isNullInput0, isNullInput1));
-        }
-
-        return call;
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static void projectJoinInputs(
-            RelNode[] inputRels,
-            List<RexNode> leftJoinKeys,
-            List<RexNode> rightJoinKeys,
-            int systemColCount,
-            List<Integer> leftKeys,
-            List<Integer> rightKeys,
-            List<Integer> outputProj) {
-        RelNode leftRel = inputRels[0];
-        RelNode rightRel = inputRels[1];
-        final RelOptCluster cluster = leftRel.getCluster();
-        final RexBuilder rexBuilder = cluster.getRexBuilder();
-
-        int origLeftInputSize = leftRel.getRowType().getFieldCount();
-        int origRightInputSize = rightRel.getRowType().getFieldCount();
-
-        final List<RexNode> newLeftFields = new ArrayList<>();
-        final List<@Nullable String> newLeftFieldNames = new ArrayList<>();
-
-        final List<RexNode> newRightFields = new ArrayList<>();
-        final List<@Nullable String> newRightFieldNames = new ArrayList<>();
-        int leftKeyCount = leftJoinKeys.size();
-        int rightKeyCount = rightJoinKeys.size();
-        int i;
-
-        for (i = 0; i < systemColCount; i++) {
-            outputProj.add(i);
-        }
-
-        for (i = 0; i < origLeftInputSize; i++) {
-            final RelDataTypeField field = leftRel.getRowType().getFieldList().get(i);
-            newLeftFields.add(rexBuilder.makeInputRef(field.getType(), i));
-            newLeftFieldNames.add(field.getName());
-            outputProj.add(systemColCount + i);
-        }
-
-        int newLeftKeyCount = 0;
-        for (i = 0; i < leftKeyCount; i++) {
-            RexNode leftKey = leftJoinKeys.get(i);
-
-            if (leftKey instanceof RexInputRef) {
-                // already added to the projected left fields
-                // only need to remember the index in the join key list
-                leftKeys.add(((RexInputRef) leftKey).getIndex());
-            } else {
-                newLeftFields.add(leftKey);
-                newLeftFieldNames.add(null);
-                leftKeys.add(origLeftInputSize + newLeftKeyCount);
-                newLeftKeyCount++;
-            }
-        }
-
-        int leftFieldCount = origLeftInputSize + newLeftKeyCount;
-        for (i = 0; i < origRightInputSize; i++) {
-            final RelDataTypeField field = rightRel.getRowType().getFieldList().get(i);
-            newRightFields.add(rexBuilder.makeInputRef(field.getType(), i));
-            newRightFieldNames.add(field.getName());
-            outputProj.add(systemColCount + leftFieldCount + i);
-        }
-
-        int newRightKeyCount = 0;
-        for (i = 0; i < rightKeyCount; i++) {
-            RexNode rightKey = rightJoinKeys.get(i);
-
-            if (rightKey instanceof RexInputRef) {
-                // already added to the projected left fields
-                // only need to remember the index in the join key list
-                rightKeys.add(((RexInputRef) rightKey).getIndex());
-            } else {
-                newRightFields.add(rightKey);
-                newRightFieldNames.add(null);
-                rightKeys.add(origRightInputSize + newRightKeyCount);
-                newRightKeyCount++;
-            }
-        }
-
-        final RelBuilder relBuilder = RelFactories.LOGICAL_BUILDER.create(cluster, null);
-
-        // added project if need to produce new keys than the original input
-        // fields
-        if (newLeftKeyCount > 0) {
-            leftRel =
-                    relBuilder
-                            .push(leftRel)
-                            .project(newLeftFields, newLeftFieldNames, true)
-                            .build();
-        }
-
-        if (newRightKeyCount > 0) {
-            rightRel =
-                    relBuilder.push(rightRel).project(newRightFields, newRightFieldNames).build();
-        }
-
-        inputRels[0] = leftRel;
-        inputRels[1] = rightRel;
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode createProjectJoinRel(List<Integer> outputProj, RelNode joinRel) {
-        int newProjectOutputSize = outputProj.size();
-        List<RelDataTypeField> joinOutputFields = joinRel.getRowType().getFieldList();
-
-        // If no projection was passed in, or the number of desired projection
-        // columns is the same as the number of columns returned from the
-        // join, then no need to create a projection
-        if (newProjectOutputSize > 0 && newProjectOutputSize < joinOutputFields.size()) {
-            final PairList<RexNode, String> newProjects = PairList.of();
-            final RelBuilder relBuilder =
-                    RelFactories.LOGICAL_BUILDER.create(joinRel.getCluster(), null);
-            final RexBuilder rexBuilder = relBuilder.getRexBuilder();
-            for (int fieldIndex : outputProj) {
-                final RelDataTypeField field = joinOutputFields.get(fieldIndex);
-                newProjects.add(
-                        rexBuilder.makeInputRef(field.getType(), fieldIndex), field.getName());
-            }
-
-            // Create a project rel on the output of the join.
-            return relBuilder
-                    .push(joinRel)
-                    .project(newProjects.leftList(), newProjects.rightList(), true)
-                    .build();
-        }
-
-        return joinRel;
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static void registerAbstractRels(RelOptPlanner planner) {
-        registerAbstractRules(planner);
-    }
-
-    @Experimental
-    public static void registerAbstractRules(RelOptPlanner planner) {
-        RelOptRules.ABSTRACT_RULES.forEach(planner::addRule);
-    }
-
-    @Experimental
-    public static void registerAbstractRelationalRules(RelOptPlanner planner) {
-        RelOptRules.ABSTRACT_RELATIONAL_RULES.forEach(planner::addRule);
-        if (CalciteSystemProperty.COMMUTE.value()) {
-            planner.addRule(CoreRules.JOIN_ASSOCIATE);
-        }
-        // todo: rule which makes Project({OrdinalRef}) disappear
-    }
-
-    private static void registerEnumerableRules(RelOptPlanner planner) {
-        EnumerableRules.ENUMERABLE_RULES.forEach(planner::addRule);
-    }
-
-    private static void registerBaseRules(RelOptPlanner planner) {
-        RelOptRules.BASE_RULES.forEach(planner::addRule);
-    }
-
-    @SuppressWarnings("unused")
-    private static void registerReductionRules(RelOptPlanner planner) {
-        RelOptRules.CONSTANT_REDUCTION_RULES.forEach(planner::addRule);
-    }
-
-    private static void registerMaterializationRules(RelOptPlanner planner) {
-        RelOptRules.MATERIALIZATION_RULES.forEach(planner::addRule);
-    }
-
-    @SuppressWarnings("unused")
-    private static void registerCalcRules(RelOptPlanner planner) {
-        RelOptRules.CALC_RULES.forEach(planner::addRule);
-    }
-
-    @Experimental
-    public static void registerDefaultRules(
-            RelOptPlanner planner, boolean enableMaterializations, boolean enableBindable) {
-        if (CalciteSystemProperty.ENABLE_COLLATION_TRAIT.value()) {
-            registerAbstractRelationalRules(planner);
-        }
-        registerAbstractRules(planner);
-        registerBaseRules(planner);
-
-        if (enableMaterializations) {
-            registerMaterializationRules(planner);
-        }
-        if (enableBindable) {
-            for (RelOptRule rule : Bindables.RULES) {
-                planner.addRule(rule);
-            }
-        }
-        // Registers this rule for default ENUMERABLE convention
-        // because:
-        // 1. ScannableTable can bind data directly;
-        // 2. Only BindableTable supports project push down now.
-
-        // EnumerableInterpreterRule.INSTANCE would then transform
-        // the BindableTableScan to
-        // EnumerableInterpreter + BindableTableScan.
-
-        // Note: the cost of EnumerableInterpreter + BindableTableScan
-        // is always bigger that EnumerableTableScan because of the additional
-        // EnumerableInterpreter node, but if there are pushing projects or filter,
-        // we prefer BindableTableScan instead,
-        // see BindableTableScan#computeSelfCost.
-        planner.addRule(Bindables.BINDABLE_TABLE_SCAN_RULE);
-        planner.addRule(CoreRules.PROJECT_TABLE_SCAN);
-        planner.addRule(CoreRules.PROJECT_INTERPRETER_TABLE_SCAN);
-
-        if (CalciteSystemProperty.ENABLE_ENUMERABLE.value()) {
-            registerEnumerableRules(planner);
-            planner.addRule(EnumerableRules.TO_INTERPRETER);
-        }
-
-        if (enableBindable && CalciteSystemProperty.ENABLE_ENUMERABLE.value()) {
-            planner.addRule(EnumerableRules.TO_BINDABLE);
-        }
-
-        if (CalciteSystemProperty.ENABLE_STREAM.value()) {
-            for (RelOptRule rule : StreamRules.RULES) {
-                planner.addRule(rule);
-            }
-        }
-
-        planner.addRule(CoreRules.FILTER_REDUCE_EXPRESSIONS);
-    }
-
-    /**
-     * Dumps a plan as a string.
-     *
-     * @param header Header to print before the plan. Ignored if the format is XML
-     * @param rel Relational expression to explain
-     * @param format Output format
-     * @param detailLevel Detail level
-     * @return Plan
-     */
-    public static String dumpPlan(
-            String header, RelNode rel, SqlExplainFormat format, SqlExplainLevel detailLevel) {
-        StringWriter sw = new StringWriter();
-        PrintWriter pw = new PrintWriter(sw);
-        if (!header.isEmpty()) {
-            pw.println(header);
-        }
-        RelWriter planWriter;
-        switch (format) {
-            case XML:
-                planWriter = new RelXmlWriter(pw, detailLevel);
-                break;
-            case JSON:
-                planWriter = new RelJsonWriter();
-                rel.explain(planWriter);
-                return ((RelJsonWriter) planWriter).asString();
-            case DOT:
-                planWriter = new RelDotWriter(pw, detailLevel, false);
-                break;
-            default:
-                planWriter = new RelWriterImpl(pw, detailLevel, false);
-        }
-        rel.explain(planWriter);
-        pw.flush();
-        return sw.toString();
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static String dumpPlan(
-            String header, RelNode rel, boolean asXml, SqlExplainLevel detailLevel) {
-        return dumpPlan(
-                header, rel, asXml ? SqlExplainFormat.XML : SqlExplainFormat.TEXT, detailLevel);
-    }
-
-    /**
-     * Creates the row type descriptor for the result of a DML operation, which is a single column
-     * named ROWCOUNT of type BIGINT for INSERT; a single column named PLAN for EXPLAIN.
-     *
-     * @param kind Kind of node
-     * @param typeFactory factory to use for creating type descriptor
-     * @return created type
-     */
-    public static RelDataType createDmlRowType(SqlKind kind, RelDataTypeFactory typeFactory) {
-        switch (kind) {
-            case INSERT:
-            case DELETE:
-            case UPDATE:
-            case MERGE:
-                return typeFactory.createStructType(
-                        PairList.of(
-                                AvaticaConnection.ROWCOUNT_COLUMN_NAME,
-                                typeFactory.createSqlType(SqlTypeName.BIGINT)));
-            case EXPLAIN:
-                return typeFactory.createStructType(
-                        PairList.of(
-                                AvaticaConnection.PLAN_COLUMN_NAME,
-                                typeFactory.createSqlType(
-                                        SqlTypeName.VARCHAR, RelDataType.PRECISION_NOT_SPECIFIED)));
-            default:
-                throw Util.unexpected(kind);
-        }
-    }
-
-    /**
-     * Returns whether two types are equal using 'equals'.
-     *
-     * @param desc1 Description of first type
-     * @param type1 First type
-     * @param desc2 Description of second type
-     * @param type2 Second type
-     * @param litmus What to do if an error is detected (types are not equal)
-     * @return Whether the types are equal
-     */
-    public static boolean eq(
-            final String desc1,
-            RelDataType type1,
-            final String desc2,
-            RelDataType type2,
-            Litmus litmus) {
-        // if any one of the types is ANY return true
-        if (type1.getSqlTypeName() == SqlTypeName.ANY
-                || type2.getSqlTypeName() == SqlTypeName.ANY) {
-            return litmus.succeed();
-        }
-
-        if (!type1.equals(type2)) {
-            return litmus.fail(
-                    "type mismatch:\n{}:\n{}\n{}:\n{}",
-                    desc1,
-                    type1.getFullTypeString(),
-                    desc2,
-                    type2.getFullTypeString());
-        }
-        return litmus.succeed();
-    }
-
-    // ----- FLINK MODIFICATION BEGIN -----
-    // Backport from Calcite (CALCITE-6764)
-    public static boolean eqUpToNullability(
-            boolean ignoreNullability,
-            final String desc1,
-            RelDataType type1,
-            final String desc2,
-            RelDataType type2,
-            Litmus litmus) {
-        if (type1.getSqlTypeName() == SqlTypeName.ANY
-                || type2.getSqlTypeName() == SqlTypeName.ANY) {
-            return litmus.succeed();
-        }
-
-        boolean success;
-        if (ignoreNullability) {
-            success = SqlTypeUtil.equalSansNullability(type1, type2);
-        } else {
-            success = type1.equals(type2);
-        }
-
-        if (!success) {
-            return litmus.fail(
-                    "type mismatch:\n{}:\n{}\n{}:\n{}",
-                    desc1,
-                    type1.getFullTypeString(),
-                    desc2,
-                    type2.getFullTypeString());
-        }
-        return litmus.succeed();
-    }
-
-    // ----- FLINK MODIFICATION END -----
-
-    /**
-     * Returns whether two types are equal using {@link #areRowTypesEqual(RelDataType, RelDataType,
-     * boolean)}. Both types must not be null.
-     *
-     * @param desc1 Description of role of first type
-     * @param type1 First type
-     * @param desc2 Description of role of second type
-     * @param type2 Second type
-     * @param litmus Whether to assert if they are not equal
-     * @return Whether the types are equal
-     */
-    public static boolean equal(
-            final String desc1,
-            RelDataType type1,
-            final String desc2,
-            RelDataType type2,
-            Litmus litmus) {
-        if (!areRowTypesEqual(type1, type2, false)) {
-            return litmus.fail(getFullTypeDifferenceString(desc1, type1, desc2, type2));
-        }
-        return litmus.succeed();
-    }
-
-    /**
-     * Returns the detailed difference of two types.
-     *
-     * @param sourceDesc description of role of source type
-     * @param sourceType source type
-     * @param targetDesc description of role of target type
-     * @param targetType target type
-     * @return the detailed difference of two types
-     */
-    public static String getFullTypeDifferenceString(
-            final String sourceDesc,
-            RelDataType sourceType,
-            final String targetDesc,
-            RelDataType targetType) {
-        if (sourceType == targetType) {
-            return "";
-        }
-
-        final int sourceFieldCount = sourceType.getFieldCount();
-        final int targetFieldCount = targetType.getFieldCount();
-        if (sourceFieldCount != targetFieldCount) {
-            return "Type mismatch: the field sizes are not equal.\n"
-                    + sourceDesc
-                    + ": "
-                    + sourceType.getFullTypeString()
-                    + "\n"
-                    + targetDesc
-                    + ": "
-                    + targetType.getFullTypeString();
-        }
-
-        final StringBuilder stringBuilder = new StringBuilder();
-        final List<RelDataTypeField> f1 = sourceType.getFieldList();
-        final List<RelDataTypeField> f2 = targetType.getFieldList();
-        for (Pair<RelDataTypeField, RelDataTypeField> pair : Pair.zip(f1, f2)) {
-            final RelDataType t1 = pair.left.getType();
-            final RelDataType t2 = pair.right.getType();
-            // If one of the types is ANY comparison should succeed
-            if (sourceType.getSqlTypeName() == SqlTypeName.ANY
-                    || targetType.getSqlTypeName() == SqlTypeName.ANY) {
-                continue;
-            }
-            if (!t1.equals(t2)) {
-                stringBuilder.append(pair.left.getName());
-                stringBuilder.append(": ");
-                stringBuilder.append(t1.getFullTypeString());
-                stringBuilder.append(" -> ");
-                stringBuilder.append(t2.getFullTypeString());
-                stringBuilder.append("\n");
-            }
-        }
-        final String difference = stringBuilder.toString();
-        if (!difference.isEmpty()) {
-            return "Type mismatch:\n"
-                    + sourceDesc
-                    + ": "
-                    + sourceType.getFullTypeString()
-                    + "\n"
-                    + targetDesc
-                    + ": "
-                    + targetType.getFullTypeString()
-                    + "\n"
-                    + "Difference:\n"
-                    + difference;
-        } else {
-            return "";
-        }
-    }
-
-    /** Returns whether two relational expressions have the same row-type. */
-    public static boolean equalType(
-            String desc0, RelNode rel0, String desc1, RelNode rel1, Litmus litmus) {
-        // TODO: change 'equal' to 'eq', which is stronger.
-        return equal(desc0, rel0.getRowType(), desc1, rel1.getRowType(), litmus);
-    }
-
-    /**
-     * Returns a translation of the <code>IS DISTINCT FROM</code> (or <code>IS
-     * NOT DISTINCT FROM</code>) sql operator.
-     *
-     * @param neg if false, returns a translation of IS NOT DISTINCT FROM
-     */
-    public static RexNode isDistinctFrom(RexBuilder rexBuilder, RexNode x, RexNode y, boolean neg) {
-        RexNode ret = null;
-        if (x.getType().isStruct()) {
-            assert y.getType().isStruct();
-            List<RelDataTypeField> xFields = x.getType().getFieldList();
-            List<RelDataTypeField> yFields = y.getType().getFieldList();
-            assert xFields.size() == yFields.size();
-            for (Pair<RelDataTypeField, RelDataTypeField> pair : Pair.zip(xFields, yFields)) {
-                RelDataTypeField xField = pair.left;
-                RelDataTypeField yField = pair.right;
-                RexNode newX = rexBuilder.makeFieldAccess(x, xField.getIndex());
-                RexNode newY = rexBuilder.makeFieldAccess(y, yField.getIndex());
-                RexNode newCall = isDistinctFromInternal(rexBuilder, newX, newY, neg);
-                if (ret == null) {
-                    ret = newCall;
-                } else {
-                    ret = rexBuilder.makeCall(SqlStdOperatorTable.AND, ret, newCall);
-                }
-            }
-        } else {
-            ret = isDistinctFromInternal(rexBuilder, x, y, neg);
-        }
-
-        // The result of IS DISTINCT FROM is NOT NULL because it can
-        // only return TRUE or FALSE.
-        requireNonNull(ret, "ret");
-        checkArgument(!ret.getType().isNullable());
-
-        return ret;
-    }
-
-    private static RexNode isDistinctFromInternal(
-            RexBuilder rexBuilder, RexNode x, RexNode y, boolean neg) {
-
-        if (neg) {
-            // x is not distinct from y
-            // x=y IS TRUE or ((x is null) and (y is null)),
-            return rexBuilder.makeCall(
-                    SqlStdOperatorTable.OR,
-                    rexBuilder.makeCall(
-                            SqlStdOperatorTable.AND,
-                            rexBuilder.makeCall(SqlStdOperatorTable.IS_NULL, x),
-                            rexBuilder.makeCall(SqlStdOperatorTable.IS_NULL, y)),
-                    rexBuilder.makeCall(
-                            SqlStdOperatorTable.IS_TRUE,
-                            rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, x, y)));
-        } else {
-            // x is distinct from y
-            // x=y IS NOT TRUE and ((x is not null) or (y is not null)),
-            return rexBuilder.makeCall(
-                    SqlStdOperatorTable.AND,
-                    rexBuilder.makeCall(
-                            SqlStdOperatorTable.OR,
-                            rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, x),
-                            rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, y)),
-                    rexBuilder.makeCall(
-                            SqlStdOperatorTable.IS_NOT_TRUE,
-                            rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, x, y)));
-        }
-    }
-
-    /** Converts a relational expression to a string, showing just basic attributes. */
-    public static String toString(final RelNode rel) {
-        return toString(rel, SqlExplainLevel.EXPPLAN_ATTRIBUTES);
-    }
-
-    /**
-     * Converts a relational expression to a string; returns null if and only if {@code rel} is
-     * null.
-     */
-    public static @PolyNull String toString(
-            final @PolyNull RelNode rel, SqlExplainLevel detailLevel) {
-        if (rel == null) {
-            return null;
-        }
-        final StringWriter sw = new StringWriter();
-        final RelWriter planWriter = new RelWriterImpl(new PrintWriter(sw), detailLevel, false);
-        rel.explain(planWriter);
-        return sw.toString();
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode renameIfNecessary(RelNode rel, RelDataType desiredRowType) {
-        final RelDataType rowType = rel.getRowType();
-        if (rowType == desiredRowType) {
-            // Nothing to do.
-            return rel;
-        }
-        assert !rowType.equals(desiredRowType);
-
-        if (!areRowTypesEqual(rowType, desiredRowType, false)) {
-            // The row types are different ignoring names. Nothing we can do.
-            return rel;
-        }
-        rel = createRename(rel, desiredRowType.getFieldNames());
-        return rel;
-    }
-
-    public static String dumpType(RelDataType type) {
-        final StringWriter sw = new StringWriter();
-        final PrintWriter pw = new PrintWriter(sw);
-        final TypeDumper typeDumper = new TypeDumper(pw);
-        if (type.isStruct()) {
-            typeDumper.acceptFields(type.getFieldList());
-        } else {
-            typeDumper.accept(type);
-        }
-        pw.flush();
-        return sw.toString();
-    }
-
-    /**
-     * Returns the set of columns with unique names, with prior columns taking precedence over
-     * columns that appear later in the list.
-     */
-    public static List<RelDataTypeField> deduplicateColumns(
-            List<RelDataTypeField> baseColumns, List<RelDataTypeField> extendedColumns) {
-        final Set<String> dedupedFieldNames = new HashSet<>();
-        final ImmutableList.Builder<RelDataTypeField> dedupedFields = ImmutableList.builder();
-        for (RelDataTypeField f : Iterables.concat(baseColumns, extendedColumns)) {
-            if (dedupedFieldNames.add(f.getName())) {
-                dedupedFields.add(f);
-            }
-        }
-        return dedupedFields.build();
-    }
-
-    /**
-     * Decomposes a predicate into a list of expressions that are AND'ed together.
-     *
-     * @param rexPredicate predicate to be analyzed
-     * @param rexList list of decomposed RexNodes
-     */
-    public static void decomposeConjunction(@Nullable RexNode rexPredicate, List<RexNode> rexList) {
-        if (rexPredicate == null || rexPredicate.isAlwaysTrue()) {
-            return;
-        }
-        if (rexPredicate.isA(SqlKind.AND)) {
-            for (RexNode operand : ((RexCall) rexPredicate).getOperands()) {
-                decomposeConjunction(operand, rexList);
-            }
-        } else {
-            rexList.add(rexPredicate);
-        }
-    }
-
-    /**
-     * Decomposes a predicate into a list of expressions that are AND'ed together, and a list of
-     * expressions that are preceded by NOT.
-     *
-     * <p>For example, {@code a AND NOT b AND NOT (c and d) AND TRUE AND NOT FALSE} returns {@code
-     * rexList = [a], notList = [b, c AND d]}.
-     *
-     * <p>TRUE and NOT FALSE expressions are ignored. FALSE and NOT TRUE expressions are placed on
-     * {@code rexList} and {@code notList} as other expressions.
-     *
-     * <p>For example, {@code a AND TRUE AND NOT TRUE} returns {@code rexList = [a], notList =
-     * [TRUE]}.
-     *
-     * @param rexPredicate predicate to be analyzed
-     * @param rexList list of decomposed RexNodes (except those with NOT)
-     * @param notList list of decomposed RexNodes that were prefixed NOT
-     */
-    public static void decomposeConjunction(
-            @Nullable RexNode rexPredicate, List<RexNode> rexList, List<RexNode> notList) {
-        if (rexPredicate == null || rexPredicate.isAlwaysTrue()) {
-            return;
-        }
-        switch (rexPredicate.getKind()) {
-            case AND:
-                for (RexNode operand : ((RexCall) rexPredicate).getOperands()) {
-                    decomposeConjunction(operand, rexList, notList);
-                }
-                break;
-            case NOT:
-                final RexNode e = ((RexCall) rexPredicate).getOperands().get(0);
-                if (e.isAlwaysFalse()) {
-                    return;
-                }
-                switch (e.getKind()) {
-                    case OR:
-                        final List<RexNode> ors = new ArrayList<>();
-                        decomposeDisjunction(e, ors);
-                        for (RexNode or : ors) {
-                            switch (or.getKind()) {
-                                case NOT:
-                                    rexList.add(((RexCall) or).operands.get(0));
-                                    break;
-                                default:
-                                    notList.add(or);
-                            }
-                        }
-                        break;
-                    default:
-                        notList.add(e);
-                }
-                break;
-            case LITERAL:
-                if (!RexLiteral.isNullLiteral(rexPredicate)
-                        && RexLiteral.booleanValue(rexPredicate)) {
-                    return; // ignore TRUE
-                }
-            // fall through
-            default:
-                rexList.add(rexPredicate);
-                break;
-        }
-    }
-
-    /**
-     * Decomposes a predicate into a list of expressions that are OR'ed together.
-     *
-     * @param rexPredicate predicate to be analyzed
-     * @param rexList list of decomposed RexNodes
-     */
-    public static void decomposeDisjunction(@Nullable RexNode rexPredicate, List<RexNode> rexList) {
-        if (rexPredicate == null || rexPredicate.isAlwaysFalse()) {
-            return;
-        }
-        if (rexPredicate.isA(SqlKind.OR)) {
-            for (RexNode operand : ((RexCall) rexPredicate).getOperands()) {
-                decomposeDisjunction(operand, rexList);
-            }
-        } else {
-            rexList.add(rexPredicate);
-        }
-    }
-
-    /**
-     * Returns a condition decomposed by AND.
-     *
-     * <p>For example, {@code conjunctions(TRUE)} returns the empty list; {@code
-     * conjunctions(FALSE)} returns list {@code {FALSE}}.
-     */
-    public static List<RexNode> conjunctions(@Nullable RexNode rexPredicate) {
-        final List<RexNode> list = new ArrayList<>();
-        decomposeConjunction(rexPredicate, list);
-        return list;
-    }
-
-    /**
-     * Returns a condition decomposed by OR.
-     *
-     * <p>For example, {@code disjunctions(FALSE)} returns the empty list.
-     */
-    public static List<RexNode> disjunctions(RexNode rexPredicate) {
-        final List<RexNode> list = new ArrayList<>();
-        decomposeDisjunction(rexPredicate, list);
-        return list;
-    }
-
-    /**
-     * Ands two sets of join filters together, either of which can be null.
-     *
-     * @param rexBuilder rexBuilder to create AND expression
-     * @param left filter on the left that the right will be AND'd to
-     * @param right filter on the right
-     * @return AND'd filter
-     * @see org.apache.calcite.rex.RexUtil#composeConjunction
-     */
-    public static RexNode andJoinFilters(
-            RexBuilder rexBuilder, @Nullable RexNode left, @Nullable RexNode right) {
-        // don't bother AND'ing in expressions that always evaluate to
-        // true
-        if ((left != null) && !left.isAlwaysTrue()) {
-            if ((right != null) && !right.isAlwaysTrue()) {
-                left = rexBuilder.makeCall(SqlStdOperatorTable.AND, left, right);
-            }
-        } else {
-            left = right;
-        }
-
-        // Joins must have some filter
-        if (left == null) {
-            left = rexBuilder.makeLiteral(true);
-        }
-        return left;
-    }
-
-    /**
-     * Decomposes the WHERE clause of a view into predicates that constraint a column to a
-     * particular value.
-     *
-     * <p>This method is key to the validation of a modifiable view. Columns that are constrained to
-     * a single value can be omitted from the SELECT clause of a modifiable view.
-     *
-     * @param projectMap Mapping from column ordinal to the expression that populate that column, to
-     *     be populated by this method
-     * @param filters List of remaining filters, to be populated by this method
-     * @param constraint Constraint to be analyzed
-     */
-    public static void inferViewPredicates(
-            Map<Integer, RexNode> projectMap, List<RexNode> filters, RexNode constraint) {
-        for (RexNode node : conjunctions(constraint)) {
-            switch (node.getKind()) {
-                case EQUALS:
-                    final List<RexNode> operands = ((RexCall) node).getOperands();
-                    RexNode o0 = operands.get(0);
-                    RexNode o1 = operands.get(1);
-                    if (o0 instanceof RexLiteral) {
-                        o0 = operands.get(1);
-                        o1 = operands.get(0);
-                    }
-                    if (o0.getKind() == SqlKind.CAST) {
-                        o0 = ((RexCall) o0).getOperands().get(0);
-                    }
-                    if (o0 instanceof RexInputRef && o1 instanceof RexLiteral) {
-                        final int index = ((RexInputRef) o0).getIndex();
-                        if (projectMap.get(index) == null) {
-                            projectMap.put(index, o1);
-                            continue;
-                        }
-                    }
-                    break;
-                default:
-                    break;
-            }
-            filters.add(node);
-        }
-    }
-
-    /**
-     * Returns a mapping of the column ordinal in the underlying table to a column constraint of the
-     * modifiable view.
-     *
-     * @param modifiableViewTable The modifiable view which has a constraint
-     * @param targetRowType The target type
-     */
-    public static Map<Integer, RexNode> getColumnConstraints(
-            ModifiableView modifiableViewTable,
-            RelDataType targetRowType,
-            RelDataTypeFactory typeFactory) {
-        final RexBuilder rexBuilder = new RexBuilder(typeFactory);
-        final RexNode constraint = modifiableViewTable.getConstraint(rexBuilder, targetRowType);
-        final Map<Integer, RexNode> projectMap = new HashMap<>();
-        final List<RexNode> filters = new ArrayList<>();
-        RelOptUtil.inferViewPredicates(projectMap, filters, constraint);
-        assert filters.isEmpty();
-        return projectMap;
-    }
-
-    /**
-     * Ensures that a source value does not violate the constraint of the target column.
-     *
-     * @param sourceValue The insert value being validated
-     * @param targetConstraint The constraint applied to sourceValue for validation
-     * @param errorSupplier The function to apply when validation fails
-     */
-    public static void validateValueAgainstConstraint(
-            SqlNode sourceValue,
-            RexNode targetConstraint,
-            Supplier<CalciteContextException> errorSupplier) {
-        if (!(sourceValue instanceof SqlLiteral)) {
-            // We cannot guarantee that the value satisfies the constraint.
-            throw errorSupplier.get();
-        }
-        final SqlLiteral insertValue = (SqlLiteral) sourceValue;
-        final RexLiteral columnConstraint = (RexLiteral) targetConstraint;
-
-        final RexSqlStandardConvertletTable convertletTable = new RexSqlStandardConvertletTable();
-        final RexToSqlNodeConverter sqlNodeToRexConverter =
-                new RexToSqlNodeConverterImpl(convertletTable);
-        final SqlLiteral constraintValue =
-                (SqlLiteral) sqlNodeToRexConverter.convertLiteral(columnConstraint);
-
-        if (!insertValue.equals(constraintValue)) {
-            // The value does not satisfy the constraint.
-            throw errorSupplier.get();
-        }
-    }
-
-    /**
-     * Adjusts key values in a list by some fixed amount.
-     *
-     * @param keys list of key values
-     * @param adjustment the amount to adjust the key values by
-     * @return modified list
-     */
-    public static List<Integer> adjustKeys(List<Integer> keys, int adjustment) {
-        if (adjustment == 0) {
-            return keys;
-        }
-        final List<Integer> newKeys = new ArrayList<>();
-        for (int key : keys) {
-            newKeys.add(key + adjustment);
-        }
-        return newKeys;
-    }
-
-    /**
-     * Simplifies outer joins if filter above would reject nulls.
-     *
-     * @param joinRel Join
-     * @param aboveFilters Filters from above
-     * @param joinType Join type, can not be inner join
-     */
-    public static JoinRelType simplifyJoin(
-            RelNode joinRel, ImmutableList<RexNode> aboveFilters, JoinRelType joinType) {
-        // No need to simplify if the join only outputs left side.
-        if (!joinType.projectsRight()) {
-            return joinType;
-        }
-        final int nTotalFields = joinRel.getRowType().getFieldCount();
-        final int nSysFields = 0;
-        final int nFieldsLeft = joinRel.getInputs().get(0).getRowType().getFieldCount();
-        final int nFieldsRight = joinRel.getInputs().get(1).getRowType().getFieldCount();
-        assert nTotalFields == nSysFields + nFieldsLeft + nFieldsRight;
-
-        // set the reference bitmaps for the left and right children
-        ImmutableBitSet leftBitmap = ImmutableBitSet.range(nSysFields, nSysFields + nFieldsLeft);
-        ImmutableBitSet rightBitmap = ImmutableBitSet.range(nSysFields + nFieldsLeft, nTotalFields);
-
-        for (RexNode filter : aboveFilters) {
-            if (joinType.generatesNullsOnLeft() && Strong.isNotTrue(filter, leftBitmap)) {
-                joinType = joinType.cancelNullsOnLeft();
-            }
-            if (joinType.generatesNullsOnRight() && Strong.isNotTrue(filter, rightBitmap)) {
-                joinType = joinType.cancelNullsOnRight();
-            }
-            if (!joinType.isOuterJoin()) {
-                break;
-            }
-        }
-        return joinType;
-    }
-
-    /**
-     * Classifies filters according to where they should be processed. They either stay where they
-     * are, are pushed to the join (if they originated from above the join), or are pushed to one of
-     * the children. Filters that are pushed are added to list passed in as input parameters.
-     *
-     * @param joinRel join node
-     * @param filters filters to be classified
-     * @param pushInto whether filters can be pushed into the join
-     * @param pushLeft true if filters can be pushed to the left
-     * @param pushRight true if filters can be pushed to the right
-     * @param joinFilters list of filters to push to the join
-     * @param leftFilters list of filters to push to the left child
-     * @param rightFilters list of filters to push to the right child
-     * @return whether at least one filter was pushed
-     */
-    public static boolean classifyFilters(
-            RelNode joinRel,
-            List<RexNode> filters,
-            boolean pushInto,
-            boolean pushLeft,
-            boolean pushRight,
-            List<RexNode> joinFilters,
-            List<RexNode> leftFilters,
-            List<RexNode> rightFilters) {
-        RexBuilder rexBuilder = joinRel.getCluster().getRexBuilder();
-        List<RelDataTypeField> joinFields = joinRel.getRowType().getFieldList();
-        final int nSysFields = 0; // joinRel.getSystemFieldList().size();
-        final List<RelDataTypeField> leftFields =
-                joinRel.getInputs().get(0).getRowType().getFieldList();
-        final int nFieldsLeft = leftFields.size();
-        final List<RelDataTypeField> rightFields =
-                joinRel.getInputs().get(1).getRowType().getFieldList();
-        final int nFieldsRight = rightFields.size();
-        final int nTotalFields = nFieldsLeft + nFieldsRight;
-
-        // set the reference bitmaps for the left and right children
-        ImmutableBitSet leftBitmap = ImmutableBitSet.range(nSysFields, nSysFields + nFieldsLeft);
-        ImmutableBitSet rightBitmap = ImmutableBitSet.range(nSysFields + nFieldsLeft, nTotalFields);
-
-        final List<RexNode> filtersToRemove = new ArrayList<>();
-        for (RexNode filter : filters) {
-            final InputFinder inputFinder = InputFinder.analyze(filter);
-            final ImmutableBitSet inputBits = inputFinder.build();
-
-            // REVIEW - are there any expressions that need special handling
-            // and therefore cannot be pushed?
-
-            if (pushLeft && leftBitmap.contains(inputBits)) {
-                // ignore filters that always evaluate to true
-                if (!filter.isAlwaysTrue()) {
-                    // adjust the field references in the filter to reflect
-                    // that fields in the left now shift over by the number
-                    // of system fields
-                    final RexNode shiftedFilter =
-                            shiftFilter(
-                                    nSysFields,
-                                    nSysFields + nFieldsLeft,
-                                    -nSysFields,
-                                    rexBuilder,
-                                    joinFields,
-                                    nTotalFields,
-                                    leftFields,
-                                    filter);
-
-                    leftFilters.add(shiftedFilter);
-                }
-                filtersToRemove.add(filter);
-            } else if (pushRight && rightBitmap.contains(inputBits)) {
-                if (!filter.isAlwaysTrue()) {
-                    // adjust the field references in the filter to reflect
-                    // that fields in the right now shift over to the left
-                    final RexNode shiftedFilter =
-                            shiftFilter(
-                                    nSysFields + nFieldsLeft,
-                                    nTotalFields,
-                                    -(nSysFields + nFieldsLeft),
-                                    rexBuilder,
-                                    joinFields,
-                                    nTotalFields,
-                                    rightFields,
-                                    filter);
-                    rightFilters.add(shiftedFilter);
-                }
-                filtersToRemove.add(filter);
-
-            } else {
-                // If the filter can't be pushed to either child, we may push them into the join
-                if (pushInto) {
-                    if (!joinFilters.contains(filter)) {
-                        joinFilters.add(filter);
-                    }
-                    filtersToRemove.add(filter);
-                }
-            }
-        }
-
-        // Remove filters after the loop, to prevent concurrent modification.
-        if (!filtersToRemove.isEmpty()) {
-            filters.removeAll(filtersToRemove);
-        }
-
-        // Did anything change?
-        return !filtersToRemove.isEmpty();
-    }
-
-    /**
-     * Classifies filters according to where they should be processed. They either stay where they
-     * are, are pushed to the join (if they originated from above the join), or are pushed to one of
-     * the children. Filters that are pushed are added to list passed in as input parameters.
-     *
-     * @param joinRel join node
-     * @param filters filters to be classified
-     * @param joinType join type
-     * @param pushInto whether filters can be pushed into the ON clause
-     * @param pushLeft true if filters can be pushed to the left
-     * @param pushRight true if filters can be pushed to the right
-     * @param joinFilters list of filters to push to the join
-     * @param leftFilters list of filters to push to the left child
-     * @param rightFilters list of filters to push to the right child
-     * @return whether at least one filter was pushed
-     * @deprecated Use {@link RelOptUtil#classifyFilters(RelNode, List, boolean, boolean, boolean,
-     *     List, List, List)}
-     */
-    @Deprecated // to be removed before 2.0
-    public static boolean classifyFilters(
-            RelNode joinRel,
-            List<RexNode> filters,
-            JoinRelType joinType,
-            boolean pushInto,
-            boolean pushLeft,
-            boolean pushRight,
-            List<RexNode> joinFilters,
-            List<RexNode> leftFilters,
-            List<RexNode> rightFilters) {
-        RexBuilder rexBuilder = joinRel.getCluster().getRexBuilder();
-        List<RelDataTypeField> joinFields = joinRel.getRowType().getFieldList();
-        final int nTotalFields = joinFields.size();
-        final int nSysFields = 0; // joinRel.getSystemFieldList().size();
-        final List<RelDataTypeField> leftFields =
-                joinRel.getInputs().get(0).getRowType().getFieldList();
-        final int nFieldsLeft = leftFields.size();
-        final List<RelDataTypeField> rightFields =
-                joinRel.getInputs().get(1).getRowType().getFieldList();
-        final int nFieldsRight = rightFields.size();
-
-        // SemiJoin, CorrelateSemiJoin, CorrelateAntiJoin: right fields are not returned
-        assert nTotalFields
-                == (!joinType.projectsRight()
-                        ? nSysFields + nFieldsLeft
-                        : nSysFields + nFieldsLeft + nFieldsRight);
-
-        // set the reference bitmaps for the left and right children
-        ImmutableBitSet leftBitmap = ImmutableBitSet.range(nSysFields, nSysFields + nFieldsLeft);
-        ImmutableBitSet rightBitmap = ImmutableBitSet.range(nSysFields + nFieldsLeft, nTotalFields);
-
-        final List<RexNode> filtersToRemove = new ArrayList<>();
-        for (RexNode filter : filters) {
-            final InputFinder inputFinder = InputFinder.analyze(filter);
-            final ImmutableBitSet inputBits = inputFinder.build();
-
-            // REVIEW - are there any expressions that need special handling
-            // and therefore cannot be pushed?
-
-            // filters can be pushed to the left child if the left child
-            // does not generate NULLs and the only columns referenced in
-            // the filter originate from the left child
-            if (pushLeft && leftBitmap.contains(inputBits)) {
-                // ignore filters that always evaluate to true
-                if (!filter.isAlwaysTrue()) {
-                    // adjust the field references in the filter to reflect
-                    // that fields in the left now shift over by the number
-                    // of system fields
-                    final RexNode shiftedFilter =
-                            shiftFilter(
-                                    nSysFields,
-                                    nSysFields + nFieldsLeft,
-                                    -nSysFields,
-                                    rexBuilder,
-                                    joinFields,
-                                    nTotalFields,
-                                    leftFields,
-                                    filter);
-
-                    leftFilters.add(shiftedFilter);
-                }
-                filtersToRemove.add(filter);
-
-                // filters can be pushed to the right child if the right child
-                // does not generate NULLs and the only columns referenced in
-                // the filter originate from the right child
-            } else if (pushRight && rightBitmap.contains(inputBits)) {
-                if (!filter.isAlwaysTrue()) {
-                    // adjust the field references in the filter to reflect
-                    // that fields in the right now shift over to the left;
-                    // since we never push filters to a NULL generating
-                    // child, the types of the source should match the dest
-                    // so we don't need to explicitly pass the destination
-                    // fields to RexInputConverter
-                    final RexNode shiftedFilter =
-                            shiftFilter(
-                                    nSysFields + nFieldsLeft,
-                                    nTotalFields,
-                                    -(nSysFields + nFieldsLeft),
-                                    rexBuilder,
-                                    joinFields,
-                                    nTotalFields,
-                                    rightFields,
-                                    filter);
-                    rightFilters.add(shiftedFilter);
-                }
-                filtersToRemove.add(filter);
-
-            } else {
-                // If the filter can't be pushed to either child and the join
-                // is an inner join, push them to the join if they originated
-                // from above the join
-                if (!joinType.isOuterJoin() && pushInto) {
-                    if (!joinFilters.contains(filter)) {
-                        joinFilters.add(filter);
-                    }
-                    filtersToRemove.add(filter);
-                }
-            }
-        }
-
-        // Remove filters after the loop, to prevent concurrent modification.
-        if (!filtersToRemove.isEmpty()) {
-            filters.removeAll(filtersToRemove);
-        }
-
-        // Did anything change?
-        return !filtersToRemove.isEmpty();
-    }
-
-    private static RexNode shiftFilter(
-            int start,
-            int end,
-            int offset,
-            RexBuilder rexBuilder,
-            List<RelDataTypeField> joinFields,
-            int nTotalFields,
-            List<RelDataTypeField> rightFields,
-            RexNode filter) {
-        int[] adjustments = new int[nTotalFields];
-        for (int i = start; i < end; i++) {
-            adjustments[i] = offset;
-        }
-        return filter.accept(
-                new RexInputConverter(rexBuilder, joinFields, rightFields, adjustments));
-    }
-
-    /**
-     * Splits a filter into two lists, depending on whether or not the filter only references its
-     * child input.
-     *
-     * @param childBitmap Fields in the child
-     * @param predicate filters that will be split
-     * @param pushable returns the list of filters that can be pushed to the child input
-     * @param notPushable returns the list of filters that cannot be pushed to the child input
-     */
-    public static void splitFilters(
-            ImmutableBitSet childBitmap,
-            @Nullable RexNode predicate,
-            List<RexNode> pushable,
-            List<RexNode> notPushable) {
-        // for each filter, if the filter only references the child inputs,
-        // then it can be pushed
-        for (RexNode filter : conjunctions(predicate)) {
-            ImmutableBitSet filterRefs = InputFinder.bits(filter);
-            if (childBitmap.contains(filterRefs)) {
-                pushable.add(filter);
-            } else {
-                notPushable.add(filter);
-            }
-        }
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static boolean checkProjAndChildInputs(Project project, boolean checkNames) {
-        int n = project.getProjects().size();
-        RelDataType inputType = project.getInput().getRowType();
-        if (inputType.getFieldList().size() != n) {
-            return false;
-        }
-        List<RelDataTypeField> projFields = project.getRowType().getFieldList();
-        List<RelDataTypeField> inputFields = inputType.getFieldList();
-        boolean namesDifferent = false;
-        for (int i = 0; i < n; ++i) {
-            RexNode exp = project.getProjects().get(i);
-            if (!(exp instanceof RexInputRef)) {
-                return false;
-            }
-            RexInputRef fieldAccess = (RexInputRef) exp;
-            if (i != fieldAccess.getIndex()) {
-                // can't support reorder yet
-                return false;
-            }
-            if (checkNames) {
-                String inputFieldName = inputFields.get(i).getName();
-                String projFieldName = projFields.get(i).getName();
-                if (!projFieldName.equals(inputFieldName)) {
-                    namesDifferent = true;
-                }
-            }
-        }
-
-        // inputs are the same; return value depends on the checkNames
-        // parameter
-        return !checkNames || namesDifferent;
-    }
-
-    /**
-     * Creates projection expressions reflecting the swapping of a join's input.
-     *
-     * @param newJoin the RelNode corresponding to the join with its inputs swapped
-     * @param origJoin original LogicalJoin
-     * @param origOrder if true, create the projection expressions to reflect the original
-     *     (pre-swapped) join projection; otherwise, create the projection to reflect the order of
-     *     the swapped projection
-     * @return array of expression representing the swapped join inputs
-     */
-    public static List<RexNode> createSwappedJoinExprs(
-            RelNode newJoin, Join origJoin, boolean origOrder) {
-        final List<RelDataTypeField> newJoinFields = newJoin.getRowType().getFieldList();
-        final RexBuilder rexBuilder = newJoin.getCluster().getRexBuilder();
-        final List<RexNode> exps = new ArrayList<>();
-        final int nFields =
-                origOrder
-                        ? origJoin.getRight().getRowType().getFieldCount()
-                        : origJoin.getLeft().getRowType().getFieldCount();
-        for (int i = 0; i < newJoinFields.size(); i++) {
-            final int source = (i + nFields) % newJoinFields.size();
-            RelDataTypeField field = origOrder ? newJoinFields.get(source) : newJoinFields.get(i);
-            exps.add(rexBuilder.makeInputRef(field.getType(), source));
-        }
-        return exps;
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RexNode pushFilterPastProject(RexNode filter, final Project projRel) {
-        return pushPastProject(filter, projRel);
-    }
-
-    /**
-     * Converts an expression that is based on the output fields of a {@link Project} to an
-     * equivalent expression on the Project's input fields.
-     *
-     * @param node The expression to be converted
-     * @param project Project underneath the expression
-     * @return converted expression
-     */
-    public static RexNode pushPastProject(RexNode node, Project project) {
-        return node.accept(pushShuttle(project));
-    }
-
-    /**
-     * Converts a list of expressions that are based on the output fields of a {@link Project} to
-     * equivalent expressions on the Project's input fields.
-     *
-     * @param nodes The expressions to be converted
-     * @param project Project underneath the expression
-     * @return converted expressions
-     */
-    public static List<RexNode> pushPastProject(List<? extends RexNode> nodes, Project project) {
-        return pushShuttle(project).visitList(nodes);
-    }
-
-    public static @Nullable RexNode pushPastProjectUnlessBloat(
-            RexNode node, Project project, int bloat) {
-        List<RexNode> newConditions =
-                pushPastProjectUnlessBloat(Collections.singletonList(node), project, bloat);
-        if (newConditions == null || newConditions.size() != 1) {
-            return null;
-        }
-        return newConditions.get(0);
-    }
-
-    /**
-     * As {@link #pushPastProject}, but returns null if the resulting expressions are significantly
-     * more complex.
-     *
-     * @param bloat Maximum allowable increase in complexity
-     */
-    public static @Nullable List<RexNode> pushPastProjectUnlessBloat(
-            List<? extends RexNode> nodes, Project project, int bloat) {
-        if (bloat < 0) {
-            // If bloat is negative never merge.
-            return null;
-        }
-        if (RexOver.containsOver(nodes, null) && project.containsOver()) {
-            // Is it valid relational algebra to apply windowed function to a windowed
-            // function? Possibly. But it's invalid SQL, so don't go there.
-            return null;
-        }
-        final List<RexNode> list = pushPastProject(nodes, project);
-        final int bottomCount = RexUtil.nodeCount(project.getProjects());
-        final int topCount = RexUtil.nodeCount(nodes);
-        final int mergedCount = RexUtil.nodeCount(list);
-        if (mergedCount > bottomCount + topCount + bloat) {
-            // The merged expression is more complex than the input expressions.
-            // Do not merge.
-            return null;
-        }
-        return list;
-    }
-
-    private static RexShuttle pushShuttle(final Project project) {
-        return new RexShuttle() {
-            @Override
-            public RexNode visitInputRef(RexInputRef ref) {
-                return project.getProjects().get(ref.getIndex());
-            }
-        };
-    }
-
-    /**
-     * Converts an expression that is based on the output fields of a {@link Calc} to an equivalent
-     * expression on the Calc's input fields.
-     *
-     * @param node The expression to be converted
-     * @param calc Calc underneath the expression
-     * @return converted expression
-     */
-    public static RexNode pushPastCalc(RexNode node, Calc calc) {
-        return node.accept(pushShuttle(calc));
-    }
-
-    private static RexShuttle pushShuttle(final Calc calc) {
-        final List<RexNode> projects =
-                Util.transform(
-                        calc.getProgram().getProjectList(), calc.getProgram()::expandLocalRef);
-        return new RexShuttle() {
-            @Override
-            public RexNode visitInputRef(RexInputRef ref) {
-                return projects.get(ref.getIndex());
-            }
-        };
-    }
-
-    /**
-     * Creates a new {@link org.apache.calcite.rel.rules.MultiJoin} to reflect projection references
-     * from a {@link Project} that is on top of the {@link org.apache.calcite.rel.rules.MultiJoin}.
-     *
-     * @param multiJoin the original MultiJoin
-     * @param project the Project on top of the MultiJoin
-     * @return the new MultiJoin
-     */
-    public static MultiJoin projectMultiJoin(MultiJoin multiJoin, Project project) {
-        // Locate all input references in the projection expressions as well
-        // the post-join filter.  Since the filter effectively sits in
-        // between the LogicalProject and the MultiJoin, the projection needs
-        // to include those filter references.
-        ImmutableBitSet inputRefs =
-                InputFinder.bits(project.getProjects(), multiJoin.getPostJoinFilter());
-
-        // create new copies of the bitmaps
-        List<RelNode> multiJoinInputs = multiJoin.getInputs();
-        List<BitSet> newProjFields = new ArrayList<>();
-        for (RelNode multiJoinInput : multiJoinInputs) {
-            newProjFields.add(new BitSet(multiJoinInput.getRowType().getFieldCount()));
-        }
-
-        // set the bits found in the expressions
-        int currInput = -1;
-        int startField = 0;
-        int nFields = 0;
-        for (int bit : inputRefs) {
-            while (bit >= (startField + nFields)) {
-                startField += nFields;
-                currInput++;
-                assert currInput < multiJoinInputs.size();
-                nFields = multiJoinInputs.get(currInput).getRowType().getFieldCount();
-            }
-            newProjFields.get(currInput).set(bit - startField);
-        }
-
-        // create a new MultiJoin containing the new field bitmaps
-        // for each input
-        return new MultiJoin(
-                multiJoin.getCluster(),
-                multiJoin.getInputs(),
-                multiJoin.getJoinFilter(),
-                multiJoin.getRowType(),
-                multiJoin.isFullOuterJoin(),
-                multiJoin.getOuterJoinConditions(),
-                multiJoin.getJoinTypes(),
-                Util.transform(newProjFields, ImmutableBitSet::fromBitSet),
-                multiJoin.getJoinFieldRefCountsMap(),
-                multiJoin.getPostJoinFilter());
-    }
-
-    public static <T extends RelNode> T addTrait(T rel, RelTrait trait) {
-        //noinspection unchecked
-        return (T) rel.copy(rel.getTraitSet().replace(trait), rel.getInputs());
-    }
-
-    /** Returns a shallow copy of a relational expression with a particular input replaced. */
-    public static RelNode replaceInput(RelNode parent, int ordinal, RelNode newInput) {
-        final List<RelNode> inputs = new ArrayList<>(parent.getInputs());
-        if (inputs.get(ordinal) == newInput) {
-            return parent;
-        }
-        inputs.set(ordinal, newInput);
-        return parent.copy(parent.getTraitSet(), inputs);
-    }
-
-    /**
-     * Creates a {@link org.apache.calcite.rel.logical.LogicalProject} that projects particular
-     * fields of its input, according to a mapping.
-     */
-    public static RelNode createProject(RelNode child, Mappings.TargetMapping mapping) {
-        return createProject(child, Mappings.asListNonNull(mapping.inverse()));
-    }
-
-    public static RelNode createProject(
-            RelNode child,
-            Mappings.TargetMapping mapping,
-            RelFactories.ProjectFactory projectFactory) {
-        return createProject(projectFactory, child, Mappings.asListNonNull(mapping.inverse()));
-    }
-
-    /**
-     * Returns the relational table node for {@code tableName} if it occurs within a relational
-     * expression {@code root} otherwise an empty option is returned.
-     */
-    public static @Nullable RelOptTable findTable(RelNode root, final String tableName) {
-        try {
-            RelShuttle visitor =
-                    new RelHomogeneousShuttle() {
-                        @Override
-                        public RelNode visit(TableScan scan) {
-                            final RelOptTable scanTable = scan.getTable();
-                            final List<String> qualifiedName = scanTable.getQualifiedName();
-                            if (qualifiedName.get(qualifiedName.size() - 1).equals(tableName)) {
-                                throw new Util.FoundOne(scanTable);
-                            }
-                            return super.visit(scan);
-                        }
-                    };
-            root.accept(visitor);
-            return null;
-        } catch (Util.FoundOne e) {
-            Util.swallow(e, null);
-            return (RelOptTable) e.getNode();
-        }
-    }
-
-    /**
-     * Returns whether relational expression {@code target} occurs within a relational expression
-     * {@code ancestor}.
-     */
-    public static boolean contains(RelNode ancestor, final RelNode target) {
-        if (ancestor == target) {
-            // Short-cut common case.
-            return true;
-        }
-        try {
-            new RelVisitor() {
-                @Override
-                public void visit(RelNode node, int ordinal, @Nullable RelNode parent) {
-                    if (node == target) {
-                        throw Util.FoundOne.NULL;
-                    }
-                    super.visit(node, ordinal, parent);
-                }
-                // CHECKSTYLE: IGNORE 1
-            }.go(ancestor);
-            return false;
-        } catch (Util.FoundOne e) {
-            return true;
-        }
-    }
-
-    /**
-     * Within a relational expression {@code query}, replaces occurrences of {@code find} with
-     * {@code replace}.
-     */
-    public static RelNode replace(RelNode query, RelNode find, RelNode replace) {
-        if (find == replace) {
-            // Short-cut common case.
-            return query;
-        }
-        assert equalType("find", find, "replace", replace, Litmus.THROW);
-        if (query == find) {
-            // Short-cut another common case.
-            return replace;
-        }
-        return replaceRecurse(query, find, replace);
-    }
-
-    /** Helper for {@link #replace}. */
-    private static RelNode replaceRecurse(RelNode query, RelNode find, RelNode replace) {
-        if (query == find) {
-            return replace;
-        }
-        final List<RelNode> inputs = query.getInputs();
-        if (!inputs.isEmpty()) {
-            final List<RelNode> newInputs = new ArrayList<>();
-            for (RelNode input : inputs) {
-                newInputs.add(replaceRecurse(input, find, replace));
-            }
-            if (!newInputs.equals(inputs)) {
-                return query.copy(query.getTraitSet(), newInputs);
-            }
-        }
-        return query;
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelOptTable.ToRelContext getContext(RelOptCluster cluster) {
-        return ViewExpanders.simpleContext(cluster);
-    }
-
-    /** Returns the number of {@link org.apache.calcite.rel.core.Join} nodes in a tree. */
-    public static int countJoins(RelNode rootRel) {
-        /** Visitor that counts join nodes. */
-        class JoinCounter extends RelVisitor {
-            int joinCount;
-
-            @Override
-            public void visit(
-                    RelNode node,
-                    int ordinal,
-                    @org.checkerframework.checker.nullness.qual.Nullable RelNode parent) {
-                if (node instanceof Join) {
-                    ++joinCount;
-                }
-                super.visit(node, ordinal, parent);
-            }
-
-            int run(RelNode node) {
-                go(node);
-                return joinCount;
-            }
-        }
-
-        return new JoinCounter().run(rootRel);
-    }
-
-    /** Permutes a record type according to a mapping. */
-    public static RelDataType permute(
-            RelDataTypeFactory typeFactory, RelDataType rowType, Mapping mapping) {
-        return typeFactory.createStructType(Mappings.apply3(mapping, rowType.getFieldList()));
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode createProject(
-            RelNode child, List<? extends RexNode> exprList, List<String> fieldNameList) {
-        final RelBuilder relBuilder = RelFactories.LOGICAL_BUILDER.create(child.getCluster(), null);
-        return relBuilder.push(child).project(exprList, fieldNameList, true).build();
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode createProject(
-            RelNode child,
-            List<Pair<RexNode, ? extends @Nullable String>> projectList,
-            boolean optimize) {
-        final RelBuilder relBuilder = RelFactories.LOGICAL_BUILDER.create(child.getCluster(), null);
-        return relBuilder
-                .push(child)
-                .projectNamed(Pair.left(projectList), Pair.right(projectList), !optimize)
-                .build();
-    }
-
-    /**
-     * Creates a relational expression that projects the given fields of the input.
-     *
-     * <p>Optimizes if the fields are the identity projection.
-     *
-     * @param child Input relational expression
-     * @param posList Source of each projected field
-     * @return Relational expression that projects given fields
-     */
-    public static RelNode createProject(final RelNode child, final List<Integer> posList) {
-        return createProject(RelFactories.DEFAULT_PROJECT_FACTORY, child, posList);
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode createProject(
-            RelNode child,
-            List<? extends RexNode> exprs,
-            List<? extends @Nullable String> fieldNames,
-            boolean optimize) {
-        final RelBuilder relBuilder = RelFactories.LOGICAL_BUILDER.create(child.getCluster(), null);
-        return relBuilder.push(child).projectNamed(exprs, fieldNames, !optimize).build();
-    }
-
-    // CHECKSTYLE: IGNORE 1
-    /**
-     * @deprecated Use {@link RelBuilder#projectNamed(Iterable, Iterable, boolean)}
-     */
-    @Deprecated // to be removed before 2.0
-    public static RelNode createProject(
-            RelNode child,
-            List<? extends RexNode> exprs,
-            List<? extends @Nullable String> fieldNames,
-            boolean optimize,
-            RelBuilder relBuilder) {
-        return relBuilder.push(child).projectNamed(exprs, fieldNames, !optimize).build();
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode createRename(RelNode rel, List<? extends @Nullable String> fieldNames) {
-        final List<RelDataTypeField> fields = rel.getRowType().getFieldList();
-        assert fieldNames.size() == fields.size();
-        final List<RexNode> refs =
-                new AbstractList<RexNode>() {
-                    @Override
-                    public int size() {
-                        return fields.size();
-                    }
-
-                    @Override
-                    public RexNode get(int index) {
-                        return RexInputRef.of(index, fields);
-                    }
-                };
-        final RelBuilder relBuilder = RelFactories.LOGICAL_BUILDER.create(rel.getCluster(), null);
-        return relBuilder.push(rel).projectNamed(refs, fieldNames, false).build();
-    }
-
-    /**
-     * Creates a relational expression which permutes the output fields of a relational expression
-     * according to a permutation.
-     *
-     * <p>Optimizations:
-     *
-     * <ul>
-     *   <li>If the relational expression is a {@link org.apache.calcite.rel.logical.LogicalCalc} or
-     *       {@link org.apache.calcite.rel.logical.LogicalProject} that is already acting as a
-     *       permutation, combines the new permutation with the old;
-     *   <li>If the permutation is the identity, returns the original relational expression.
-     * </ul>
-     *
-     * <p>If a permutation is combined with its inverse, these optimizations would combine to remove
-     * them both.
-     *
-     * @param rel Relational expression
-     * @param permutation Permutation to apply to fields
-     * @param fieldNames Field names; if null, or if a particular entry is null, the name of the
-     *     permuted field is used
-     * @return relational expression which permutes its input fields
-     */
-    public static RelNode permute(
-            RelNode rel, Permutation permutation, @Nullable List<String> fieldNames) {
-        if (permutation.isIdentity()) {
-            return rel;
-        }
-        if (rel instanceof LogicalCalc) {
-            LogicalCalc calc = (LogicalCalc) rel;
-            Permutation permutation1 = calc.getProgram().getPermutation();
-            if (permutation1 != null) {
-                Permutation permutation2 = permutation.product(permutation1);
-                return permute(rel, permutation2, null);
-            }
-        }
-        if (rel instanceof LogicalProject) {
-            Permutation permutation1 = ((LogicalProject) rel).getPermutation();
-            if (permutation1 != null) {
-                Permutation permutation2 = permutation.product(permutation1);
-                return permute(rel, permutation2, null);
-            }
-        }
-        final List<RelDataType> outputTypeList = new ArrayList<>();
-        final List<String> outputNameList = new ArrayList<>();
-        final List<RexNode> exprList = new ArrayList<>();
-        final List<RexLocalRef> projectRefList = new ArrayList<>();
-        final List<RelDataTypeField> fields = rel.getRowType().getFieldList();
-        final RelOptCluster cluster = rel.getCluster();
-        for (int i = 0; i < permutation.getTargetCount(); i++) {
-            int target = permutation.getTarget(i);
-            final RelDataTypeField targetField = fields.get(target);
-            outputTypeList.add(targetField.getType());
-            outputNameList.add(
-                    ((fieldNames == null)
-                                    || (fieldNames.size() <= i)
-                                    || (fieldNames.get(i) == null))
-                            ? targetField.getName()
-                            : fieldNames.get(i));
-            exprList.add(cluster.getRexBuilder().makeInputRef(fields.get(i).getType(), i));
-            final int source = permutation.getSource(i);
-            projectRefList.add(new RexLocalRef(source, fields.get(source).getType()));
-        }
-        final RelDataTypeFactory typeFactory = cluster.getTypeFactory();
-        final RexProgram program =
-                new RexProgram(
-                        rel.getRowType(),
-                        exprList,
-                        projectRefList,
-                        null,
-                        typeFactory.createStructType(outputTypeList, outputNameList));
-        return LogicalCalc.create(rel, program);
-    }
-
-    /**
-     * Creates a relational expression that projects the given fields of the input.
-     *
-     * <p>Optimizes if the fields are the identity projection.
-     *
-     * @param factory ProjectFactory
-     * @param child Input relational expression
-     * @param posList Source of each projected field
-     * @return Relational expression that projects given fields
-     */
-    public static RelNode createProject(
-            final RelFactories.ProjectFactory factory,
-            final RelNode child,
-            final List<Integer> posList) {
-        RelDataType rowType = child.getRowType();
-        final List<String> fieldNames = rowType.getFieldNames();
-        final RelBuilder relBuilder = RelBuilder.proto(factory).create(child.getCluster(), null);
-        final List<RexNode> exprs =
-                new AbstractList<RexNode>() {
-                    @Override
-                    public int size() {
-                        return posList.size();
-                    }
-
-                    @Override
-                    public RexNode get(int index) {
-                        final int pos = posList.get(index);
-                        return relBuilder.getRexBuilder().makeInputRef(child, pos);
-                    }
-                };
-        final List<String> names = Util.select(fieldNames, posList);
-        return relBuilder.push(child).projectNamed(exprs, names, false).build();
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode projectMapping(
-            RelNode rel,
-            Mapping mapping,
-            @Nullable List<String> fieldNames,
-            RelFactories.ProjectFactory projectFactory) {
-        assert mapping.getMappingType().isSingleSource();
-        assert mapping.getMappingType().isMandatorySource();
-        if (mapping.isIdentity()) {
-            return rel;
-        }
-        final List<String> outputNameList = new ArrayList<>();
-        final List<RexNode> exprList = new ArrayList<>();
-        final List<RelDataTypeField> fields = rel.getRowType().getFieldList();
-        final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
-        for (int i = 0; i < mapping.getTargetCount(); i++) {
-            final int source = mapping.getSource(i);
-            final RelDataTypeField sourceField = fields.get(source);
-            outputNameList.add(
-                    ((fieldNames == null)
-                                    || (fieldNames.size() <= i)
-                                    || (fieldNames.get(i) == null))
-                            ? sourceField.getName()
-                            : fieldNames.get(i));
-            exprList.add(rexBuilder.makeInputRef(rel, source));
-        }
-        return projectFactory.createProject(
-                rel, ImmutableList.of(), exprList, outputNameList, ImmutableSet.of());
-    }
-
-    /** Predicate for if a {@link Calc} does not contain windowed aggregates. */
-    public static boolean notContainsWindowedAgg(Calc calc) {
-        return !calc.containsOver();
-    }
-
-    /** Predicate for if a {@link Filter} does not contain windowed aggregates. */
-    public static boolean notContainsWindowedAgg(Filter filter) {
-        return !filter.containsOver();
-    }
-
-    /** Predicate for if a {@link Project} does not contain windowed aggregates. */
-    public static boolean notContainsWindowedAgg(Project project) {
-        return !project.containsOver();
-    }
-
-    /** Policies for handling two- and three-valued boolean logic. */
-    public enum Logic {
-        /** Three-valued boolean logic. */
-        TRUE_FALSE_UNKNOWN,
-
-        /** Nulls are not possible. */
-        TRUE_FALSE,
-
-        /**
-         * Two-valued logic where UNKNOWN is treated as FALSE.
-         *
-         * <p>"x IS TRUE" produces the same result, and "WHERE x", "JOIN ... ON x" and "HAVING x"
-         * have the same effect.
-         */
-        UNKNOWN_AS_FALSE,
-
-        /**
-         * Two-valued logic where UNKNOWN is treated as TRUE.
-         *
-         * <p>"x IS FALSE" produces the same result, as does "WHERE NOT x", etc.
-         *
-         * <p>In particular, this is the mode used by "WHERE k NOT IN q". If "k IN q" produces TRUE
-         * or UNKNOWN, "NOT k IN q" produces FALSE or UNKNOWN and the row is eliminated; if "k IN q"
-         * it returns FALSE, the row is retained by the WHERE clause.
-         */
-        UNKNOWN_AS_TRUE,
-
-        /**
-         * A semi-join will have been applied, so that only rows for which the value is TRUE will
-         * have been returned.
-         */
-        TRUE,
-
-        /**
-         * An anti-semi-join will have been applied, so that only rows for which the value is FALSE
-         * will have been returned.
-         *
-         * <p>Currently only used within {@link LogicVisitor}, to ensure that 'NOT (NOT EXISTS (q))'
-         * behaves the same as 'EXISTS (q)')
-         */
-        FALSE;
-
-        public Logic negate() {
-            switch (this) {
-                case UNKNOWN_AS_FALSE:
-                case TRUE:
-                    return UNKNOWN_AS_TRUE;
-                case UNKNOWN_AS_TRUE:
-                    return UNKNOWN_AS_FALSE;
-                default:
-                    return this;
-            }
-        }
-
-        /**
-         * Variant of {@link #negate()} to be used within {@link LogicVisitor}, where FALSE values
-         * may exist.
-         */
-        public Logic negate2() {
-            switch (this) {
-                case FALSE:
-                    return TRUE;
-                case TRUE:
-                    return FALSE;
-                case UNKNOWN_AS_FALSE:
-                    return UNKNOWN_AS_TRUE;
-                case UNKNOWN_AS_TRUE:
-                    return UNKNOWN_AS_FALSE;
-                default:
-                    return this;
-            }
-        }
-    }
-
-    /**
-     * Pushes down expressions in "equal" join condition.
-     *
-     * <p>For example, given "emp JOIN dept ON emp.deptno + 1 = dept.deptno", adds a project above
-     * "emp" that computes the expression "emp.deptno + 1". The resulting join condition is a simple
-     * combination of AND, equals, and input fields, plus the remaining non-equal conditions.
-     *
-     * @param originalJoin Join whose condition is to be pushed down
-     * @param relBuilder Factory to create project operator
-     */
-    public static RelNode pushDownJoinConditions(Join originalJoin, RelBuilder relBuilder) {
-        RexNode joinCond = originalJoin.getCondition();
-        final JoinRelType joinType = originalJoin.getJoinType();
-
-        final List<RexNode> extraLeftExprs = new ArrayList<>();
-        final List<RexNode> extraRightExprs = new ArrayList<>();
-        final int leftCount = originalJoin.getLeft().getRowType().getFieldCount();
-        final int rightCount = originalJoin.getRight().getRowType().getFieldCount();
-
-        // You cannot push a 'get' because field names might change.
-        //
-        // Pushing sub-queries is OK in principle (if they don't reference both
-        // sides of the join via correlating variables) but we'd rather not do it
-        // yet.
-        if (!containsGet(joinCond) && RexUtil.SubQueryFinder.find(joinCond) == null) {
-            joinCond =
-                    pushDownEqualJoinConditions(
-                            joinCond,
-                            leftCount,
-                            rightCount,
-                            extraLeftExprs,
-                            extraRightExprs,
-                            relBuilder.getRexBuilder());
-        }
-
-        final PairList<RexNode, @Nullable String> pairs = PairList.of();
-        relBuilder.push(originalJoin.getLeft());
-        if (!extraLeftExprs.isEmpty()) {
-            final List<RelDataTypeField> fields = relBuilder.peek().getRowType().getFieldList();
-            for (int i = 0, n = leftCount + extraLeftExprs.size(); i < n; i++) {
-                if (i < leftCount) {
-                    RelDataTypeField field = fields.get(i);
-                    pairs.add(new RexInputRef(i, field.getType()), field.getName());
-                } else {
-                    pairs.add(extraLeftExprs.get(i - leftCount), null);
-                }
-            }
-            relBuilder.project(pairs.leftList(), pairs.rightList());
-            pairs.clear();
-        }
-
-        relBuilder.push(originalJoin.getRight());
-        if (!extraRightExprs.isEmpty()) {
-            final List<RelDataTypeField> fields = relBuilder.peek().getRowType().getFieldList();
-            final int newLeftCount = leftCount + extraLeftExprs.size();
-            for (int i = 0, n = rightCount + extraRightExprs.size(); i < n; i++) {
-                if (i < rightCount) {
-                    RelDataTypeField field = fields.get(i);
-                    pairs.add(new RexInputRef(i, field.getType()), field.getName());
-                } else {
-                    pairs.add(
-                            RexUtil.shift(extraRightExprs.get(i - rightCount), -newLeftCount),
-                            null);
-                }
-            }
-            relBuilder.project(pairs.leftList(), pairs.rightList());
-            pairs.clear();
-        }
-
-        final RelNode right = relBuilder.build();
-        final RelNode left = relBuilder.build();
-        if (joinType == JoinRelType.ASOF || joinType == JoinRelType.LEFT_ASOF) {
-            LogicalAsofJoin ljoin = (LogicalAsofJoin) originalJoin;
-            RexNode match =
-                    RexUtil.shift(ljoin.getMatchCondition(), leftCount, extraLeftExprs.size());
-            RelNode copy = ljoin.copy(originalJoin.getTraitSet(), joinCond, match, left, right);
-            relBuilder.push(copy);
-        } else {
-            relBuilder.push(
-                    originalJoin.copy(
-                            originalJoin.getTraitSet(),
-                            joinCond,
-                            left,
-                            right,
-                            joinType,
-                            originalJoin.isSemiJoinDone()));
-        }
-        if (!extraLeftExprs.isEmpty() || !extraRightExprs.isEmpty()) {
-            final int totalFields =
-                    joinType.projectsRight()
-                            ? leftCount
-                                    + extraLeftExprs.size()
-                                    + rightCount
-                                    + extraRightExprs.size()
-                            : leftCount + extraLeftExprs.size();
-            final int[] mappingRanges =
-                    joinType.projectsRight()
-                            ? new int[] {
-                                0,
-                                0,
-                                leftCount,
-                                leftCount,
-                                leftCount + extraLeftExprs.size(),
-                                rightCount
-                            }
-                            : new int[] {0, 0, leftCount};
-            Mappings.TargetMapping mapping =
-                    Mappings.createShiftMapping(totalFields, mappingRanges);
-            relBuilder.project(relBuilder.fields(mapping.inverse()));
-        }
-        return relBuilder.build();
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode pushDownJoinConditions(Join originalJoin) {
-        return pushDownJoinConditions(originalJoin, RelFactories.LOGICAL_BUILDER);
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static RelNode pushDownJoinConditions(
-            Join originalJoin, RelFactories.ProjectFactory projectFactory) {
-        return pushDownJoinConditions(originalJoin, RelBuilder.proto(projectFactory));
-    }
-
-    private static RelNode pushDownJoinConditions(
-            Join originalJoin, RelBuilderFactory relBuilderFactory) {
-        return pushDownJoinConditions(
-                originalJoin, relBuilderFactory.create(originalJoin.getCluster(), null));
-    }
-
-    private static boolean containsGet(RexNode node) {
-        try {
-            node.accept(
-                    new RexVisitorImpl<Void>(true) {
-                        @Override
-                        public Void visitCall(RexCall call) {
-                            if (call.getOperator() == RexBuilder.GET_OPERATOR) {
-                                throw Util.FoundOne.NULL;
-                            }
-                            return super.visitCall(call);
-                        }
-                    });
-            return false;
-        } catch (Util.FoundOne e) {
-            return true;
-        }
-    }
-
-    /**
-     * Pushes down parts of a join condition.
-     *
-     * <p>For example, given "emp JOIN dept ON emp.deptno + 1 = dept.deptno", adds a project above
-     * "emp" that computes the expression "emp.deptno + 1". The resulting join condition is a simple
-     * combination of AND, equals, and input fields.
-     */
-    private static RexNode pushDownEqualJoinConditions(
-            RexNode condition,
-            int leftCount,
-            int rightCount,
-            List<RexNode> extraLeftExprs,
-            List<RexNode> extraRightExprs,
-            RexBuilder builder) {
-        // Normalize the condition first
-        RexNode node =
-                (condition instanceof RexCall)
-                        ? collapseExpandedIsNotDistinctFromExpr((RexCall) condition, builder)
-                        : condition;
-
-        switch (node.getKind()) {
-            case EQUALS:
-            case IS_NOT_DISTINCT_FROM:
-                final RexCall call0 = (RexCall) node;
-                final RexNode leftRex = call0.getOperands().get(0);
-                final RexNode rightRex = call0.getOperands().get(1);
-                final ImmutableBitSet leftBits = RelOptUtil.InputFinder.bits(leftRex);
-                final ImmutableBitSet rightBits = RelOptUtil.InputFinder.bits(rightRex);
-                final int pivot = leftCount + extraLeftExprs.size();
-                Side lside = Side.of(leftBits, pivot);
-                Side rside = Side.of(rightBits, pivot);
-                if (!lside.opposite(rside)) {
-                    return call0;
-                }
-            // fall through
-            case AND:
-                final RexCall call = (RexCall) node;
-                final List<RexNode> list = new ArrayList<>();
-                List<RexNode> operands = Lists.newArrayList(call.getOperands());
-                for (int i = 0; i < operands.size(); i++) {
-                    RexNode operand = operands.get(i);
-                    if (operand instanceof RexCall) {
-                        operand = collapseExpandedIsNotDistinctFromExpr((RexCall) operand, builder);
-                    }
-                    if (node.getKind() == SqlKind.AND
-                            && operand.getKind() != SqlKind.EQUALS
-                            && operand.getKind() != SqlKind.IS_NOT_DISTINCT_FROM) {
-                        // one of the join condition is neither EQ nor INDF
-                        list.add(operand);
-                    } else {
-                        final int left2 = leftCount + extraLeftExprs.size();
-                        final RexNode e =
-                                pushDownEqualJoinConditions(
-                                        operand,
-                                        leftCount,
-                                        rightCount,
-                                        extraLeftExprs,
-                                        extraRightExprs,
-                                        builder);
-                        if (!e.equals(operand)) {
-                            final List<RexNode> remainingOperands = Util.skip(operands, i + 1);
-                            final int left3 = leftCount + extraLeftExprs.size();
-                            fix(remainingOperands, left2, left3);
-                            fix(list, left2, left3);
-                        }
-                        list.add(e);
-                    }
-                }
-                if (!list.equals(call.getOperands())) {
-                    return call.clone(call.getType(), list);
-                }
-                return call;
-            case OR:
-            case INPUT_REF:
-            case LITERAL:
-            case NOT:
-                return node;
-            default:
-                final ImmutableBitSet bits = RelOptUtil.InputFinder.bits(node);
-                final int mid = leftCount + extraLeftExprs.size();
-                switch (Side.of(bits, mid)) {
-                    case LEFT:
-                        fix(extraRightExprs, mid, mid + 1);
-                        extraLeftExprs.add(node);
-                        return new RexInputRef(mid, node.getType());
-                    case RIGHT:
-                        final int index2 = mid + rightCount + extraRightExprs.size();
-                        extraRightExprs.add(node);
-                        return new RexInputRef(index2, node.getType());
-                    case BOTH:
-                    case EMPTY:
-                    default:
-                        return node;
-                }
-        }
-    }
-
-    private static void fix(List<RexNode> operands, int before, int after) {
-        if (before == after) {
-            return;
-        }
-        operands.replaceAll(e -> RexUtil.shift(e, before, after - before));
-    }
-
-    /**
-     * Determines whether any of the fields in a given relational expression may contain null
-     * values, taking into account constraints on the field types and also deduced predicates.
-     *
-     * <p>The method is cautious: It may sometimes return {@code true} when the actual answer is
-     * {@code false}. In particular, it does this when there is no executor, or the executor is not
-     * a sub-class of {@link RexExecutorImpl}.
-     */
-    private static boolean containsNullableFields(RelNode r) {
-        final RexBuilder rexBuilder = r.getCluster().getRexBuilder();
-        final RelDataType rowType = r.getRowType();
-        final List<RexNode> list = new ArrayList<>();
-        final RelMetadataQuery mq = r.getCluster().getMetadataQuery();
-        for (RelDataTypeField field : rowType.getFieldList()) {
-            if (field.getType().isNullable()) {
-                list.add(
-                        rexBuilder.makeCall(
-                                SqlStdOperatorTable.IS_NOT_NULL,
-                                rexBuilder.makeInputRef(field.getType(), field.getIndex())));
-            }
-        }
-        if (list.isEmpty()) {
-            // All columns are declared NOT NULL.
-            return false;
-        }
-        final RelOptPredicateList predicates = mq.getPulledUpPredicates(r);
-        if (RelOptPredicateList.isEmpty(predicates)) {
-            // We have no predicates, so cannot deduce that any of the fields
-            // declared NULL are really NOT NULL.
-            return true;
-        }
-        final RexExecutor executor = r.getCluster().getPlanner().getExecutor();
-        if (!(executor instanceof RexExecutorImpl)) {
-            // Cannot proceed without an executor.
-            return true;
-        }
-        final RexImplicationChecker checker =
-                new RexImplicationChecker(rexBuilder, executor, rowType);
-        final RexNode first = RexUtil.composeConjunction(rexBuilder, predicates.pulledUpPredicates);
-        final RexNode second = RexUtil.composeConjunction(rexBuilder, list);
-        // Suppose we have EMP(empno INT NOT NULL, mgr INT),
-        // and predicates [empno > 0, mgr > 0].
-        // We make first: "empno > 0 AND mgr > 0"
-        // and second: "mgr IS NOT NULL"
-        // and ask whether first implies second.
-        // It does, so we have no nullable columns.
-        return !checker.implies(first, second);
-    }
-
-    // ~ Inner Classes ----------------------------------------------------------
-
-    /**
-     * A {@code RelShuttle} which propagates all the hints of relational expression to their
-     * children nodes.
-     *
-     * <p>Given a plan:
-     *
-     * <blockquote>
-     *
-     * <pre>
-     *            Filter (Hint1)
-     *                |
-     *               Join
-     *              /    \
-     *            Scan  Project (Hint2)
-     *                     |
-     *                    Scan2
-     * </pre>
-     *
-     * </blockquote>
-     *
-     * <p>Every hint has a {@code inheritPath} (integers list) which records its propagate path,
-     * number `0` represents the hint is propagated from the first(left) child, number `1`
-     * represents the hint is propagated from the second(right) child, so the plan would have hints
-     * path as follows (assumes each hint can be propagated to all child nodes):
-     *
-     * <ul>
-     *   <li>Filter would have hints {Hint1[]}
-     *   <li>Join would have hints {Hint1[0]}
-     *   <li>Scan would have hints {Hint1[0, 0]}
-     *   <li>Project would have hints {Hint1[0,1], Hint2[]}
-     *   <li>Scan2 would have hints {[Hint1[0, 1, 0], Hint2[0]}
-     * </ul>
-     */
-    private static class RelHintPropagateShuttle extends RelHomogeneousShuttle {
-        /** Stack recording the hints and its current inheritPath. */
-        private final Deque<Pair<List<RelHint>, Deque<Integer>>> inheritPaths = new ArrayDeque<>();
-
-        /**
-         * The hint strategies to decide if a hint should be attached to a relational expression.
-         */
-        private final HintStrategyTable hintStrategies;
-
-        RelHintPropagateShuttle(HintStrategyTable hintStrategies) {
-            this.hintStrategies = hintStrategies;
-        }
-
-        /** Visits a particular child of a parent. */
-        @Override
-        protected RelNode visitChild(RelNode parent, int i, RelNode child) {
-            inheritPaths.forEach(inheritPath -> inheritPath.right.push(i));
-            try {
-                RelNode child2 = child.accept(this);
-                if (child2 != child) {
-                    final List<RelNode> newInputs = new ArrayList<>(parent.getInputs());
-                    newInputs.set(i, child2);
-                    return parent.copy(parent.getTraitSet(), newInputs);
-                }
-                return parent;
-            } finally {
-                inheritPaths.forEach(inheritPath -> inheritPath.right.pop());
-            }
-        }
-
-        @Override
-        public RelNode visit(RelNode other) {
-            if (other instanceof Hintable) {
-                return visitHintable(other);
-            } else {
-                return visitChildren(other);
-            }
-        }
-
-        /**
-         * Handle the {@link Hintable}s.
-         *
-         * <p>There are two cases to handle hints:
-         *
-         * <ul>
-         *   <li>For TableScan: table scan is always a leaf node, attach the hints of the
-         *       propagation path directly;
-         *   <li>For other {@link Hintable}s: if the node has hints itself, that means, these hints
-         *       are query hints that need to propagate to its children, so we do these things:
-         *       <ol>
-         *         <li>push the hints with empty inheritPath to the stack
-         *         <li>visit the children nodes and propagate the hints
-         *         <li>pop the hints pushed in step1
-         *         <li>attach the hints of the propagation path
-         *       </ol>
-         *       if the node does not have hints, attach the hints of the propagation path directly.
-         * </ul>
-         *
-         * @param node {@link Hintable} to handle
-         * @return New copy of the {@code hintable} with propagated hints attached
-         */
-        private RelNode visitHintable(RelNode node) {
-            final List<RelHint> topHints = ((Hintable) node).getHints();
-            final boolean hasHints = !topHints.isEmpty();
-            final boolean hasQueryHints = hasHints && !(node instanceof TableScan);
-            if (hasQueryHints) {
-                inheritPaths.push(Pair.of(topHints, new ArrayDeque<>()));
-            }
-            final RelNode node1 = visitChildren(node);
-            if (hasQueryHints) {
-                inheritPaths.pop();
-            }
-            return attachHints(node1);
-        }
-
-        private RelNode attachHints(RelNode original) {
-            assert original instanceof Hintable;
-            if (!inheritPaths.isEmpty()) {
-                final List<RelHint> hints =
-                        inheritPaths.stream()
-                                .sorted(Comparator.comparingInt(o -> o.right.size()))
-                                .map(path -> copyWithInheritPath(path.left, path.right))
-                                .reduce(
-                                        new ArrayList<>(),
-                                        (acc, hints1) -> {
-                                            acc.addAll(hints1);
-                                            return acc;
-                                        });
-                final List<RelHint> filteredHints = hintStrategies.apply(hints, original);
-                if (!filteredHints.isEmpty()) {
-                    return ((Hintable) original).attachHints(filteredHints);
-                }
-            }
-            return original;
-        }
-
-        private static List<RelHint> copyWithInheritPath(
-                List<RelHint> hints, Deque<Integer> inheritPath) {
-            // Copy the Dequeue in reverse order.
-            final List<Integer> path = new ArrayList<>();
-            final Iterator<Integer> iterator = inheritPath.descendingIterator();
-            while (iterator.hasNext()) {
-                path.add(iterator.next());
-            }
-            return hints.stream().map(hint -> hint.copy(path)).collect(Collectors.toList());
-        }
-    }
-
-    /**
-     * A {@code RelShuttle} which propagates the given hints to the sub-tree from the root node. It
-     * stops the search of current path if the node already has hints or the whole propagation if
-     * there is already a matched node.
-     *
-     * <p>Given a plan:
-     *
-     * <blockquote>
-     *
-     * <pre>
-     *            Filter
-     *                |
-     *               Join
-     *              /    \
-     *            Scan  Project (Hint2)
-     *                     |
-     *                    Scan2
-     * </pre>
-     *
-     * </blockquote>
-     *
-     * <p>The [Filter, Join, Scan] are the candidates(in sequence) to propagate, the whole
-     * propagation ends if we append the given hints to a node successfully.
-     */
-    private static class SubTreeHintPropagateShuttle extends RelHomogeneousShuttle {
-        /** Stack recording the appended inheritPath. */
-        private final List<Integer> appendPath = new ArrayList<>();
-
-        /**
-         * The hint strategies to decide if a hint should be attached to a relational expression.
-         */
-        private final HintStrategyTable hintStrategies;
-
-        /** Hints to propagate. */
-        private final List<RelHint> hints;
-
-        SubTreeHintPropagateShuttle(HintStrategyTable hintStrategies, List<RelHint> hints) {
-            this.hintStrategies = hintStrategies;
-            this.hints = hints;
-        }
-
-        /** Visits a particular child of a parent. */
-        @Override
-        protected RelNode visitChild(RelNode parent, int i, RelNode child) {
-            appendPath.add(i);
-            try {
-                RelNode child2 = child.accept(this);
-                if (child2 != child) {
-                    final List<RelNode> newInputs = new ArrayList<>(parent.getInputs());
-                    newInputs.set(i, child2);
-                    return parent.copy(parent.getTraitSet(), newInputs);
-                }
-                return parent;
-            } finally {
-                // Remove the last element.
-                appendPath.remove(appendPath.size() - 1);
-            }
-        }
-
-        @Override
-        public RelNode visit(RelNode other) {
-            if (this.appendPath.size() > 3) {
-                // Returns early if the visiting depth is bigger than 3
-                return other;
-            }
-            if (other instanceof Hintable) {
-                return visitHintable(other);
-            } else {
-                return visitChildren(other);
-            }
-        }
-
-        /**
-         * Handle the {@link Hintable}s.
-         *
-         * <p>Try to propagate the given hints to the node, the propagation finishes if:
-         *
-         * <ul>
-         *   <li>This hintable already has hints, that means, the rel is definitely not created by a
-         *       planner rule(or copied by the planner rule)
-         *   <li>This hintable appended the hints successfully
-         * </ul>
-         *
-         * @param node {@link Hintable} to handle
-         * @return New copy of the {@code hintable} with propagated hints attached
-         */
-        private RelNode visitHintable(RelNode node) {
-            final List<RelHint> topHints = ((Hintable) node).getHints();
-            final boolean hasHints = !topHints.isEmpty();
-            if (hasHints) {
-                // This node is definitely not created by the planner, returns early.
-                return node;
-            }
-            final RelNode node1 = attachHints(node);
-            if (node1 != node) {
-                return node1;
-            }
-            return visitChildren(node);
-        }
-
-        private RelNode attachHints(RelNode original) {
-            assert original instanceof Hintable;
-            final List<RelHint> hints =
-                    this.hints.stream()
-                            .map(hint -> copyWithAppendPath(hint, appendPath))
-                            .collect(Collectors.toList());
-            final List<RelHint> filteredHints = hintStrategies.apply(hints, original);
-            if (!filteredHints.isEmpty()) {
-                return ((Hintable) original).attachHints(filteredHints);
-            }
-            return original;
-        }
-
-        private static RelHint copyWithAppendPath(RelHint hint, List<Integer> appendPaths) {
-            if (appendPaths.isEmpty()) {
-                return hint;
-            } else {
-                List<Integer> newPath = new ArrayList<>(hint.inheritPath);
-                newPath.addAll(appendPaths);
-                return hint.copy(newPath);
-            }
-        }
-    }
-
-    /**
-     * A {@code RelShuttle} which resets all the hints of a relational expression to what they are
-     * originally like.
-     *
-     * <p>This would trigger a reverse transformation of what {@link RelHintPropagateShuttle} does.
-     *
-     * <p>Transformation rules:
-     *
-     * <ul>
-     *   <li>Project: remove the hints that have non-empty inherit path (which means the hint was
-     *       not originally declared from it);
-     *   <li>Aggregate: remove the hints that have non-empty inherit path;
-     *   <li>Join: remove all the hints;
-     *   <li>TableScan: remove the hints that have non-empty inherit path.
-     * </ul>
-     */
-    private static class ResetHintsShuttle extends RelHomogeneousShuttle {
-        @Override
-        public RelNode visit(RelNode node) {
-            node = visitChildren(node);
-            if (node instanceof Hintable) {
-                node = resetHints((Hintable) node);
-            }
-            return node;
-        }
-
-        private static RelNode resetHints(Hintable hintable) {
-            if (hintable.getHints().isEmpty()) {
-                return (RelNode) hintable;
-            }
-            final List<RelHint> resetHints =
-                    hintable.getHints().stream()
-                            .filter(hint -> hint.inheritPath.isEmpty())
-                            .collect(Collectors.toList());
-            return hintable.withHints(resetHints);
-        }
-    }
-
-    /** Visitor that finds all variables used but not stopped in an expression. */
-    private static class VariableSetVisitor extends RelVisitor {
-        final Set<CorrelationId> variables = new HashSet<>();
-
-        // implement RelVisitor
-        @Override
-        public void visit(
-                RelNode p,
-                int ordinal,
-                @org.checkerframework.checker.nullness.qual.Nullable RelNode parent) {
-            super.visit(p, ordinal, parent);
-            p.collectVariablesUsed(variables);
-
-            // Important! Remove stopped variables AFTER we visit children
-            // (which what super.visit() does)
-            variables.removeAll(p.getVariablesSet());
-        }
-    }
-
-    /** Visitor that finds all variables used in an expression. */
-    public static class VariableUsedVisitor extends RexShuttle {
-        public final Set<CorrelationId> variables = new LinkedHashSet<>();
-        public final Multimap<CorrelationId, Integer> variableFields = LinkedHashMultimap.create();
-        @NotOnlyInitialized private final @Nullable RelShuttle relShuttle;
-
-        public VariableUsedVisitor(@UnknownInitialization @Nullable RelShuttle relShuttle) {
-            this.relShuttle = relShuttle;
-        }
-
-        @Override
-        public RexNode visitCorrelVariable(RexCorrelVariable p) {
-            variables.add(p.id);
-            variableFields.put(p.id, -1);
-            return p;
-        }
-
-        @Override
-        public RexNode visitFieldAccess(RexFieldAccess fieldAccess) {
-            if (fieldAccess.getReferenceExpr() instanceof RexCorrelVariable) {
-                final RexCorrelVariable v = (RexCorrelVariable) fieldAccess.getReferenceExpr();
-                variableFields.put(v.id, fieldAccess.getField().getIndex());
-            }
-            return super.visitFieldAccess(fieldAccess);
-        }
-
-        @Override
-        public RexNode visitSubQuery(RexSubQuery subQuery) {
-            if (relShuttle != null) {
-                subQuery.rel.accept(relShuttle); // look inside sub-queries
-            }
-            return super.visitSubQuery(subQuery);
-        }
-    }
-
-    /** Shuttle that finds the set of inputs that are used. */
-    public static class InputReferencedVisitor extends RexShuttle {
-        public final NavigableSet<Integer> inputPosReferenced = new TreeSet<>();
-
-        @Override
-        public RexNode visitInputRef(RexInputRef inputRef) {
-            inputPosReferenced.add(inputRef.getIndex());
-            return inputRef;
-        }
-    }
-
-    /** Converts types to descriptive strings. */
-    public static class TypeDumper {
-        private String indent;
-        private final PrintWriter pw;
-
-        TypeDumper(PrintWriter pw) {
-            this.pw = pw;
-            this.indent = "";
-        }
-
-        void accept(RelDataType type) {
-            if (type.isStruct()) {
-                final List<RelDataTypeField> fields = type.getFieldList();
-
-                // RECORD (
-                //   I INTEGER NOT NULL,
-                //   J VARCHAR(240))
-                pw.println("RECORD (");
-                String prevIndent = indent;
-                String extraIndent = "  ";
-                this.indent = indent + extraIndent;
-                acceptFields(fields);
-                this.indent = prevIndent;
-                pw.print(")");
-                if (!type.isNullable()) {
-                    pw.print(NON_NULLABLE_SUFFIX);
-                }
-            } else if (type instanceof MultisetSqlType) {
-                // E.g. "INTEGER NOT NULL MULTISET NOT NULL"
-                RelDataType componentType =
-                        requireNonNull(
-                                type.getComponentType(),
-                                () -> "type.getComponentType() for " + type);
-                accept(componentType);
-                pw.print(" MULTISET");
-                if (!type.isNullable()) {
-                    pw.print(NON_NULLABLE_SUFFIX);
-                }
-            } else {
-                // E.g. "INTEGER" E.g. "VARCHAR(240) CHARACTER SET "ISO-8859-1"
-                // COLLATE "ISO-8859-1$en_US$primary" NOT NULL"
-                pw.print(type.getFullTypeString());
-            }
-        }
-
-        private void acceptFields(final List<RelDataTypeField> fields) {
-            for (int i = 0; i < fields.size(); i++) {
-                RelDataTypeField field = fields.get(i);
-                if (i > 0) {
-                    pw.println(",");
-                }
-                pw.print(indent);
-                pw.print(field.getName());
-                pw.print(" ");
-                accept(field.getType());
-            }
-        }
-    }
-
-    /** Visitor which builds a bitmap of the inputs used by an expression. */
-    public static class InputFinder extends RexVisitorImpl<Void> {
-        private final ImmutableBitSet.Builder bitBuilder;
-        private final @Nullable Set<RelDataTypeField> extraFields;
-
-        private InputFinder(
-                @Nullable Set<RelDataTypeField> extraFields, ImmutableBitSet.Builder bitBuilder) {
-            super(true);
-            this.bitBuilder = bitBuilder;
-            this.extraFields = extraFields;
-        }
-
-        public InputFinder() {
-            this(null);
-        }
-
-        public InputFinder(@Nullable Set<RelDataTypeField> extraFields) {
-            this(extraFields, ImmutableBitSet.builder());
-        }
-
-        public InputFinder(
-                @Nullable Set<RelDataTypeField> extraFields, ImmutableBitSet initialBits) {
-            this(extraFields, initialBits.rebuild());
-        }
-
-        /** Returns an input finder that has analyzed a given expression. */
-        public static InputFinder analyze(RexNode node) {
-            final InputFinder inputFinder = new InputFinder();
-            node.accept(inputFinder);
-            return inputFinder;
-        }
-
-        /** Returns a bit set describing the inputs used by an expression. */
-        public static ImmutableBitSet bits(RexNode node) {
-            return analyze(node).build();
-        }
-
-        /**
-         * Returns a bit set describing the inputs used by a collection of project expressions and
-         * an optional condition.
-         */
-        public static ImmutableBitSet bits(List<RexNode> exprs, @Nullable RexNode expr) {
-            final InputFinder inputFinder = new InputFinder();
-            RexUtil.apply(inputFinder, exprs, expr);
-            return inputFinder.build();
-        }
-
-        /**
-         * Returns the bit set.
-         *
-         * <p>After calling this method, you cannot do any more visits or call this method again.
-         */
-        public ImmutableBitSet build() {
-            return bitBuilder.build();
-        }
-
-        @Override
-        public Void visitInputRef(RexInputRef inputRef) {
-            bitBuilder.set(inputRef.getIndex());
-            return null;
-        }
-
-        @Override
-        public Void visitCall(RexCall call) {
-            if (call.getOperator() == RexBuilder.GET_OPERATOR) {
-                RexLiteral literal = (RexLiteral) call.getOperands().get(1);
-                if (extraFields != null) {
-                    requireNonNull(literal, () -> "first operand in " + call);
-                    String value2 = (String) literal.getValue2();
-                    requireNonNull(value2, () -> "value of the first operand in " + call);
-                    extraFields.add(new RelDataTypeFieldImpl(value2, -1, call.getType()));
-                }
-            }
-            return super.visitCall(call);
-        }
-    }
-
-    /**
-     * Walks an expression tree, converting the index of RexInputRefs based on some adjustment
-     * factor.
-     */
-    public static class RexInputConverter extends RexShuttle {
-        protected final RexBuilder rexBuilder;
-        private final @Nullable List<RelDataTypeField> srcFields;
-        protected final @Nullable List<RelDataTypeField> destFields;
-        private final @Nullable List<RelDataTypeField> leftDestFields;
-        private final @Nullable List<RelDataTypeField> rightDestFields;
-        private final int nLeftDestFields;
-        private final int[] adjustments;
-
-        /**
-         * Creates a RexInputConverter.
-         *
-         * @param rexBuilder builder for creating new RexInputRefs
-         * @param srcFields fields where the RexInputRefs originated from; if null, a new
-         *     RexInputRef is always created, referencing the input from destFields corresponding to
-         *     its current index value
-         * @param destFields fields that the new RexInputRefs will be referencing; if null, use the
-         *     type information from the source field when creating the new RexInputRef
-         * @param leftDestFields in the case where the destination is a join, these are the fields
-         *     from the left join input
-         * @param rightDestFields in the case where the destination is a join, these are the fields
-         *     from the right join input
-         * @param adjustments the amount to adjust each field by
-         */
-        private RexInputConverter(
-                RexBuilder rexBuilder,
-                @Nullable List<RelDataTypeField> srcFields,
-                @Nullable List<RelDataTypeField> destFields,
-                @Nullable List<RelDataTypeField> leftDestFields,
-                @Nullable List<RelDataTypeField> rightDestFields,
-                int[] adjustments) {
-            this.rexBuilder = rexBuilder;
-            this.srcFields = srcFields;
-            this.destFields = destFields;
-            this.adjustments = adjustments;
-            this.leftDestFields = leftDestFields;
-            this.rightDestFields = rightDestFields;
-            if (leftDestFields == null) {
-                nLeftDestFields = 0;
-            } else {
-                assert destFields == null;
-                nLeftDestFields = leftDestFields.size();
-            }
-        }
-
-        public RexInputConverter(
-                RexBuilder rexBuilder,
-                @Nullable List<RelDataTypeField> srcFields,
-                @Nullable List<RelDataTypeField> leftDestFields,
-                @Nullable List<RelDataTypeField> rightDestFields,
-                int[] adjustments) {
-            this(rexBuilder, srcFields, null, leftDestFields, rightDestFields, adjustments);
-        }
-
-        public RexInputConverter(
-                RexBuilder rexBuilder,
-                @Nullable List<RelDataTypeField> srcFields,
-                @Nullable List<RelDataTypeField> destFields,
-                int[] adjustments) {
-            this(rexBuilder, srcFields, destFields, null, null, adjustments);
-        }
-
-        public RexInputConverter(
-                RexBuilder rexBuilder,
-                @Nullable List<RelDataTypeField> srcFields,
-                int[] adjustments) {
-            this(rexBuilder, srcFields, null, null, null, adjustments);
-        }
-
-        @Override
-        public RexNode visitInputRef(RexInputRef var) {
-            int srcIndex = var.getIndex();
-            int destIndex = srcIndex + adjustments[srcIndex];
-
-            RelDataType type;
-            if (destFields != null) {
-                type = destFields.get(destIndex).getType();
-            } else if (leftDestFields != null) {
-                if (destIndex < nLeftDestFields) {
-                    type = leftDestFields.get(destIndex).getType();
-                } else {
-                    type =
-                            requireNonNull(rightDestFields, "rightDestFields")
-                                    .get(destIndex - nLeftDestFields)
-                                    .getType();
-                }
-            } else {
-                type = requireNonNull(srcFields, "srcFields").get(srcIndex).getType();
-            }
-            if ((adjustments[srcIndex] != 0)
-                    || (srcFields == null)
-                    || (type != srcFields.get(srcIndex).getType())) {
-                return rexBuilder.makeInputRef(type, destIndex);
-            } else {
-                return var;
-            }
-        }
-    }
-
-    /** What kind of sub-query. */
-    public enum SubQueryType {
-        EXISTS,
-        IN,
-        SCALAR
-    }
-
-    /** Categorizes whether a bit set contains bits left and right of a line. */
-    enum Side {
-        LEFT,
-        RIGHT,
-        BOTH,
-        EMPTY;
-
-        static Side of(ImmutableBitSet bitSet, int middle) {
-            final int firstBit = bitSet.nextSetBit(0);
-            if (firstBit < 0) {
-                return EMPTY;
-            }
-            if (firstBit >= middle) {
-                return RIGHT;
-            }
-            if (bitSet.nextSetBit(middle) < 0) {
-                return LEFT;
-            }
-            return BOTH;
-        }
-
-        public boolean opposite(Side side) {
-            return (this == LEFT && side == RIGHT) || (this == RIGHT && side == LEFT);
-        }
-    }
-
-    /**
-     * Shuttle that finds correlation variables inside a given relational expression, including
-     * those that are inside {@link RexSubQuery sub-queries}.
-     */
-    private static class CorrelationCollector extends RelHomogeneousShuttle {
-        @SuppressWarnings("assignment.type.incompatible")
-        private final VariableUsedVisitor vuv = new VariableUsedVisitor(this);
-
-        @Override
-        public RelNode visit(RelNode other) {
-            other.collectVariablesUsed(vuv.variables);
-            other.accept(vuv);
-            RelNode result = super.visit(other);
-            // Important! Remove stopped variables AFTER we visit
-            // children. (which what super.visit() does)
-            vuv.variables.removeAll(other.getVariablesSet());
-            return result;
-        }
-    }
-
-    /** Result of calling {@link org.apache.calcite.plan.RelOptUtil#createExistsPlan}. */
-    public static class Exists {
-        public final RelNode r;
-        public final boolean indicator;
-        public final boolean outerJoin;
-
-        private Exists(RelNode r, boolean indicator, boolean outerJoin) {
-            this.r = r;
-            this.indicator = indicator;
-            this.outerJoin = outerJoin;
-        }
-    }
-}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
index 7363bb119f867..0114ad194fd27 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
@@ -27,6 +27,7 @@
 import org.apache.calcite.rel.core.Join;
 import org.apache.calcite.rel.core.JoinRelType;
 import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.metadata.RelMdUtil;
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.rex.LogicVisitor;
 import org.apache.calcite.rex.RexInputRef;
@@ -161,6 +162,12 @@ private static RexNode rewriteCollection(
      */
     private static RexNode rewriteSome(
             RexSubQuery e, Set<CorrelationId> variablesSet, RelBuilder builder, int subQueryIndex) {
+        // If the sub-query is guaranteed empty, just return
+        // FALSE.
+        final RelMetadataQuery mq = e.rel.getCluster().getMetadataQuery();
+        if (RelMdUtil.isRelDefinitelyEmpty(mq, e.rel)) {
+            return builder.getRexBuilder().makeLiteral(Boolean.FALSE, e.getType(), true);
+        }
         // Most general case, where the left and right keys might have nulls, and
         // caller requires 3-valued logic return.
         //
@@ -397,22 +404,32 @@ private static RexNode rewriteSome(
                     //     then false // sub-query is empty for corresponding corr value
                     //   when q.c = 0 then false // sub-query is empty
                     //   when e.deptno is null then unknown
-                    //   when q.c <> q.d && q.d <= 1
+                    //   when q.c <> q.d && q.dd <= 1
                     //     then e.deptno != m || unknown
-                    //   when q.d = 1
+                    //   when q.dd = 1
                     //     then e.deptno != m // sub-query has the distinct result
                     //   else true
                     //   end as v
                     // from emp as e
                     // left outer join (
-                    //   select name, count(distinct *) as c, count(distinct deptno) as d,
+                    //   select name, count(*) as c, count(deptno) as d, count(distinct deptno) as
+                    // dd,
                     //       max(deptno) as m, "alwaysTrue" as indicator
                     //   from emp group by name) as q on e.name = q.name
+
+                    // Additional details on the `q.c <> q.d && q.dd <= 1` clause:
+                    // the q.c <> q.d comparison identifies if there are any null values,
+                    // since count(*) counts null values and count(deptno) does not.
+                    // if there's no null value, c should be equal to d.
+                    // the q.dd <= 1 part means: true if there is at most one non-null value
+                    // so this clause means:
+                    // "if there are any null values and there is at most one non-null value".
                     builder.push(e.rel)
                             .aggregate(
                                     builder.groupKey(),
-                                    builder.count(true, "c"),
-                                    builder.count(true, "d", builder.field(0)),
+                                    builder.count(false, "c"),
+                                    builder.count(false, "d", builder.field(0)),
+                                    builder.count(true, "dd", builder.field(0)),
                                     builder.max(builder.field(0)).as("m"));
 
                     parentQueryFields.addAll(builder.fields());
@@ -432,12 +449,12 @@ private static RexNode rewriteSome(
                                             builder.notEquals(
                                                     builder.field("d"), builder.field("c")),
                                             builder.lessThanOrEqual(
-                                                    builder.field("d"), builder.literal(1))),
+                                                    builder.field("dd"), builder.literal(1))),
                                     builder.or(
                                             builder.notEquals(
                                                     e.operands.get(0), builder.field(qAlias, "m")),
                                             literalUnknown),
-                                    builder.equals(builder.field("d"), builder.literal(1)),
+                                    builder.equals(builder.field("dd"), builder.literal(1)),
                                     builder.notEquals(
                                             e.operands.get(0), builder.field(qAlias, "m")),
                                     literalTrue);
@@ -474,15 +491,13 @@ private static RexNode rewriteExists(
             Set<CorrelationId> variablesSet,
             RelOptUtil.Logic logic,
             RelBuilder builder) {
-        // If the sub-query is guaranteed to produce at least one row, just return
+        // If the sub-query is guaranteed never empty, just return
         // TRUE.
         final RelMetadataQuery mq = e.rel.getCluster().getMetadataQuery();
-        final Double minRowCount = mq.getMinRowCount(e.rel);
-        if (minRowCount != null && minRowCount >= 1D) {
+        if (RelMdUtil.isRelDefinitelyNotEmpty(mq, e.rel)) {
             return builder.literal(true);
         }
-        final Double maxRowCount = mq.getMaxRowCount(e.rel);
-        if (maxRowCount != null && maxRowCount < 1D) {
+        if (RelMdUtil.isRelDefinitelyEmpty(mq, e.rel)) {
             return builder.literal(false);
         }
         builder.push(e.rel);
@@ -573,6 +588,12 @@ private static RexNode rewriteIn(
             RelBuilder builder,
             int offset,
             int subQueryIndex) {
+        // If the sub-query is guaranteed empty, just return
+        // FALSE.
+        final RelMetadataQuery mq = e.rel.getCluster().getMetadataQuery();
+        if (RelMdUtil.isRelDefinitelyEmpty(mq, e.rel)) {
+            return builder.getRexBuilder().makeLiteral(Boolean.FALSE, e.getType(), true);
+        }
         // Most general case, where the left and right keys might have nulls, and
         // caller requires 3-valued logic return.
         //
@@ -700,16 +721,14 @@ private static RexNode rewriteIn(
                     if (variablesSet.isEmpty()) {
                         builder.aggregate(
                                 builder.groupKey(builder.field("cs")), builder.count(false, "c"));
-
-                        // sorts input with desc order since we are interested
-                        // only in the case when one of the values is true.
-                        // When true value is absent then we are interested
-                        // only in false value.
-                        builder.sortLimit(
-                                0, 1, ImmutableList.of(builder.desc(builder.field("cs"))));
                     } else {
                         builder.distinct();
                     }
+                    // sorts input with desc order since we are interested
+                    // only in the case when one of the values is true.
+                    // When true value is absent then we are interested
+                    // only in false value.
+                    builder.sortLimit(0, 1, ImmutableList.of(builder.desc(builder.field("cs"))));
             }
             // clears expressionOperands and fields lists since
             // all expressions were used in the filter
@@ -908,14 +927,58 @@ private static void matchJoin(SubQueryRemoveRule rule, RelOptRuleCall call) {
         final RexSubQuery e = requireNonNull(RexUtil.SubQueryFinder.find(join.getCondition()));
         final RelOptUtil.Logic logic =
                 LogicVisitor.find(RelOptUtil.Logic.TRUE, ImmutableList.of(join.getCondition()), e);
-        builder.push(join.getLeft());
-        builder.push(join.getRight());
-        final int fieldCount = join.getRowType().getFieldCount();
+
+        ImmutableBitSet inputSet = RelOptUtil.InputFinder.bits(e.getOperands(), null);
+        int nFieldsLeft = join.getLeft().getRowType().getFieldCount();
+        int nFieldsRight = join.getRight().getRowType().getFieldCount();
+
+        boolean inputIntersectsLeftSide =
+                inputSet.intersects(ImmutableBitSet.range(0, nFieldsLeft));
+        boolean inputIntersectsRightSide =
+                inputSet.intersects(ImmutableBitSet.range(nFieldsLeft, nFieldsLeft + nFieldsRight));
+        if (inputIntersectsLeftSide && inputIntersectsRightSide) {
+            // The current existential rewrite needs to make join with one side of the origin join
+            // and
+            // generate a new condition to replace the on clause. But for RexNode whose operands are
+            // on either side of the join, we can't push them into join. So this rewriting is not
+            // supported.
+            return;
+        }
+
         final Set<CorrelationId> variablesSet = RelOptUtil.getVariablesUsed(e.rel);
-        final RexNode target = rule.apply(e, variablesSet, logic, builder, 2, fieldCount, 0);
-        final RexShuttle shuttle = new ReplaceSubQueryShuttle(e, target);
-        builder.join(join.getJoinType(), shuttle.apply(join.getCondition()));
-        builder.project(fields(builder, join.getRowType().getFieldCount()));
+        if (inputIntersectsLeftSide) {
+            builder.push(join.getLeft());
+
+            final RexNode target = rule.apply(e, variablesSet, logic, builder, 1, nFieldsLeft, 0);
+            final RexShuttle shuttle = new ReplaceSubQueryShuttle(e, target);
+
+            final RexNode newCond =
+                    shuttle.apply(
+                            RexUtil.shift(
+                                    join.getCondition(),
+                                    nFieldsLeft,
+                                    builder.fields().size() - nFieldsLeft));
+            builder.push(join.getRight());
+            builder.join(join.getJoinType(), newCond);
+
+            final int nFields = builder.fields().size();
+            ImmutableList<RexNode> fields =
+                    builder.fields(
+                            ImmutableBitSet.range(0, nFieldsLeft)
+                                    .union(ImmutableBitSet.range(nFields - nFieldsRight, nFields)));
+            builder.project(fields);
+        } else {
+            builder.push(join.getLeft());
+            builder.push(join.getRight());
+
+            final int nFields = join.getRowType().getFieldCount();
+            final RexNode target = rule.apply(e, variablesSet, logic, builder, 2, nFields, 0);
+            final RexShuttle shuttle = new ReplaceSubQueryShuttle(e, target);
+
+            builder.join(join.getJoinType(), shuttle.apply(join.getCondition()));
+            builder.project(fields(builder, nFields));
+        }
+
         call.transformTo(builder.build());
     }
 
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
index 9b395adec1f18..9752813928f78 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
@@ -403,10 +403,7 @@ public RelDataType createTypeWithNullability(final RelDataType type, final boole
         return canonize(newType);
     }
 
-    // ----- FLINK MODIFICATION BEGIN -----
-    // Backport from Calcite (CALCITE-6764): creates a type with specified nullability
-    // without deep-copying record field types. For record types, makes the struct
-    // itself nullable/not-nullable while keeping field types unchanged.
+    @Override
     public RelDataType enforceTypeWithNullability(final RelDataType type, final boolean nullable) {
         requireNonNull(type, "type");
         RelDataType newType;
@@ -434,8 +431,6 @@ public int size() {
         return canonize(newType);
     }
 
-    // ----- FLINK MODIFICATION END -----
-
     /**
      * Registers a type, or returns the existing type if it is already registered.
      *
@@ -672,6 +667,13 @@ public RelDataTypeFamily getFamily() {
         protected void generateTypeString(StringBuilder sb, boolean withDetail) {
             sb.append("JavaType(");
             sb.append(clazz);
+            if (clazz == String.class
+                    && charset != null
+                    && !SqlCollation.IMPLICIT.getCharset().equals(charset)) {
+                sb.append(" CHARACTER SET \"");
+                sb.append(charset.name());
+                sb.append("\"");
+            }
             sb.append(")");
         }
 
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexBuilder.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexBuilder.java
deleted file mode 100644
index d1d5a3c0cd1de..0000000000000
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexBuilder.java
+++ /dev/null
@@ -1,2206 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.rex;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableRangeSet;
-import com.google.common.collect.Range;
-import com.google.common.collect.RangeSet;
-import com.google.common.collect.TreeRangeSet;
-import org.apache.calcite.avatica.util.ByteString;
-import org.apache.calcite.avatica.util.DateTimeUtils;
-import org.apache.calcite.avatica.util.Spaces;
-import org.apache.calcite.avatica.util.TimeUnit;
-import org.apache.calcite.rel.RelNode;
-import org.apache.calcite.rel.core.AggregateCall;
-import org.apache.calcite.rel.core.CorrelationId;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.calcite.rel.type.RelDataTypeField;
-import org.apache.calcite.runtime.FlatLists;
-import org.apache.calcite.sql.SqlAggFunction;
-import org.apache.calcite.sql.SqlCollation;
-import org.apache.calcite.sql.SqlIntervalQualifier;
-import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlSpecialOperator;
-import org.apache.calcite.sql.SqlUtil;
-import org.apache.calcite.sql.fun.SqlCountAggFunction;
-import org.apache.calcite.sql.fun.SqlLibraryOperators;
-import org.apache.calcite.sql.fun.SqlStdOperatorTable;
-import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.type.ArraySqlType;
-import org.apache.calcite.sql.type.MapSqlType;
-import org.apache.calcite.sql.type.MultisetSqlType;
-import org.apache.calcite.sql.type.SqlTypeFamily;
-import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.type.SqlTypeUtil;
-import org.apache.calcite.util.DateString;
-import org.apache.calcite.util.NlsString;
-import org.apache.calcite.util.Pair;
-import org.apache.calcite.util.Sarg;
-import org.apache.calcite.util.TimeString;
-import org.apache.calcite.util.TimeWithTimeZoneString;
-import org.apache.calcite.util.TimestampString;
-import org.apache.calcite.util.TimestampWithTimeZoneString;
-import org.apache.calcite.util.Util;
-import org.checkerframework.checker.nullness.qual.Nullable;
-import org.checkerframework.checker.nullness.qual.PolyNull;
-import org.locationtech.jts.geom.Geometry;
-
-import java.math.BigDecimal;
-import java.math.MathContext;
-import java.math.RoundingMode;
-import java.nio.charset.Charset;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Calendar;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Objects;
-import java.util.function.IntPredicate;
-import java.util.stream.Collectors;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Verify.verifyNotNull;
-import static com.google.common.collect.ImmutableList.toImmutableList;
-import static java.util.Objects.requireNonNull;
-import static org.apache.calcite.linq4j.Nullness.castNonNull;
-
-/**
- * Factory for row expressions.
- *
- * <p>Some common literal values (NULL, TRUE, FALSE, 0, 1, '') are cached.
- *
- * <p>FLINK modifications (backport of CALCITE-6764): Lines 234, 241, 245, 249 ~ 253
- */
-public class RexBuilder {
-    /**
-     * Special operator that accesses an unadvertised field of an input record. This operator cannot
-     * be used in SQL queries; it is introduced temporarily during sql-to-rel translation, then
-     * replaced during the process that trims unwanted fields.
-     */
-    public static final SqlSpecialOperator GET_OPERATOR =
-            new SqlSpecialOperator("_get", SqlKind.OTHER_FUNCTION);
-
-    /** The smallest valid {@code int} value, as a {@link BigDecimal}. */
-    private static final BigDecimal INT_MIN = BigDecimal.valueOf(Integer.MIN_VALUE);
-
-    /** The largest valid {@code int} value, as a {@link BigDecimal}. */
-    private static final BigDecimal INT_MAX = BigDecimal.valueOf(Integer.MAX_VALUE);
-
-    // ~ Instance fields --------------------------------------------------------
-
-    protected final RelDataTypeFactory typeFactory;
-    private final RexLiteral booleanTrue;
-    private final RexLiteral booleanFalse;
-    private final RexLiteral charEmpty;
-    private final RexLiteral constantNull;
-    private final SqlStdOperatorTable opTab = SqlStdOperatorTable.instance();
-
-    // ~ Constructors -----------------------------------------------------------
-
-    /**
-     * Creates a RexBuilder.
-     *
-     * @param typeFactory Type factory
-     */
-    @SuppressWarnings("method.invocation.invalid")
-    public RexBuilder(RelDataTypeFactory typeFactory) {
-        this.typeFactory = typeFactory;
-        this.booleanTrue =
-                makeLiteral(
-                        Boolean.TRUE,
-                        typeFactory.createSqlType(SqlTypeName.BOOLEAN),
-                        SqlTypeName.BOOLEAN);
-        this.booleanFalse =
-                makeLiteral(
-                        Boolean.FALSE,
-                        typeFactory.createSqlType(SqlTypeName.BOOLEAN),
-                        SqlTypeName.BOOLEAN);
-        this.charEmpty =
-                makeLiteral(
-                        new NlsString("", null, null),
-                        typeFactory.createSqlType(SqlTypeName.CHAR, 0),
-                        SqlTypeName.CHAR);
-        this.constantNull =
-                makeLiteral(null, typeFactory.createSqlType(SqlTypeName.NULL), SqlTypeName.NULL);
-    }
-
-    /**
-     * Creates a list of {@link org.apache.calcite.rex.RexInputRef} expressions, projecting the
-     * fields of a given record type.
-     */
-    public List<RexNode> identityProjects(final RelDataType rowType) {
-        return Util.transform(
-                rowType.getFieldList(),
-                input -> new RexInputRef(input.getIndex(), input.getType()));
-    }
-
-    // ~ Methods ----------------------------------------------------------------
-
-    /**
-     * Returns this RexBuilder's type factory.
-     *
-     * @return type factory
-     */
-    public RelDataTypeFactory getTypeFactory() {
-        return typeFactory;
-    }
-
-    /**
-     * Returns this RexBuilder's operator table.
-     *
-     * @return operator table
-     */
-    public SqlStdOperatorTable getOpTab() {
-        return opTab;
-    }
-
-    /**
-     * Creates an expression accessing a given named field from a record.
-     *
-     * <p>NOTE: Be careful choosing the value of {@code caseSensitive}. If the field name was
-     * supplied by an end-user (e.g. as a column alias in SQL), use your session's case-sensitivity
-     * setting. Only hard-code {@code true} if you are sure that the field name is internally
-     * generated. Hard-coding {@code false} is almost certainly wrong.
-     *
-     * @param expr Expression yielding a record
-     * @param fieldName Name of field in record
-     * @param caseSensitive Whether match is case-sensitive
-     * @return Expression accessing a given named field
-     */
-    public RexNode makeFieldAccess(RexNode expr, String fieldName, boolean caseSensitive) {
-        final RelDataType type = expr.getType();
-        final RelDataTypeField field = type.getField(fieldName, caseSensitive, false);
-        if (field == null) {
-            throw new AssertionError("Type '" + type + "' has no field '" + fieldName + "'");
-        }
-        return makeFieldAccessInternal(expr, field);
-    }
-
-    /**
-     * Creates an expression accessing a field with a given ordinal from a record.
-     *
-     * @param expr Expression yielding a record
-     * @param i Ordinal of field
-     * @return Expression accessing given field
-     */
-    public RexNode makeFieldAccess(RexNode expr, int i) {
-        final RelDataType type = expr.getType();
-        final List<RelDataTypeField> fields = type.getFieldList();
-        if ((i < 0) || (i >= fields.size())) {
-            throw new AssertionError(
-                    "Field ordinal " + i + " is invalid for " + " type '" + type + "'");
-        }
-        return makeFieldAccessInternal(expr, fields.get(i));
-    }
-
-    /**
-     * Creates an expression accessing a given field from a record.
-     *
-     * @param expr Expression yielding a record
-     * @param field Field
-     * @return Expression accessing given field
-     */
-    private RexNode makeFieldAccessInternal(RexNode expr, final RelDataTypeField field) {
-        RelDataType fieldType = field.getType();
-        if (expr instanceof RexRangeRef) {
-            RexRangeRef range = (RexRangeRef) expr;
-            if (field.getIndex() < 0) {
-                return makeCall(
-                        fieldType,
-                        GET_OPERATOR,
-                        ImmutableList.of(expr, makeLiteral(field.getName())));
-            }
-            return new RexInputRef(range.getOffset() + field.getIndex(), fieldType);
-        }
-
-        if (expr.getType().isNullable()) {
-            fieldType = typeFactory.createTypeWithNullability(fieldType, true);
-        }
-        return new RexFieldAccess(expr, field, fieldType);
-    }
-
-    /** Creates a call with a list of arguments and a predetermined type. */
-    public RexNode makeCall(RelDataType returnType, SqlOperator op, List<RexNode> exprs) {
-        return makeCall(SqlParserPos.ZERO, returnType, op, exprs);
-    }
-
-    /**
-     * Creates a call with a list of arguments and a predetermined type.
-     *
-     * @param pos should be different from ZERO if the call can fail at runtime.
-     */
-    public RexNode makeCall(
-            SqlParserPos pos, RelDataType returnType, SqlOperator op, List<RexNode> exprs) {
-        return new RexCall(pos, returnType, op, exprs);
-    }
-
-    /**
-     * Creates a call with an array of arguments.
-     *
-     * <p>If you already know the return type of the call, then {@link #makeCall(SqlParserPos,
-     * RelDataType, SqlOperator, List)} is preferred.
-     */
-    public RexNode makeCall(SqlOperator op, List<? extends RexNode> exprs) {
-        return makeCall(SqlParserPos.ZERO, op, exprs);
-    }
-
-    /**
-     * Creates a call with an array of arguments.
-     *
-     * @param pos should be different from ZERO if the call can fail at runtime.
-     *     <p>If you already know the return type of the call, then {@link #makeCall(SqlParserPos,
-     *     RelDataType, SqlOperator, List)} is preferred.
-     */
-    public RexNode makeCall(SqlParserPos pos, SqlOperator op, List<? extends RexNode> exprs) {
-        final RelDataType type = deriveReturnType(op, exprs);
-        return new RexCall(pos, type, op, exprs);
-    }
-
-    /**
-     * Creates a call with a list of arguments.
-     *
-     * <p>Equivalent to <code>makeCall(ZERO, op, exprList.toArray(new RexNode[exprList.size()]))
-     * </code>.
-     */
-    public final RexNode makeCall(SqlOperator op, RexNode... exprs) {
-        return makeCall(SqlParserPos.ZERO, op, exprs);
-    }
-
-    /**
-     * Creates a call with a list of arguments.
-     *
-     * @param pos should be different from ZERO if the call can fail at runtime.
-     *     <p>Equivalent to <code>makeCall(pos, op, exprList.toArray(new RexNode[exprList.size()]))
-     *     </code>.
-     */
-    public final RexNode makeCall(SqlParserPos pos, SqlOperator op, RexNode... exprs) {
-        return makeCall(pos, op, ImmutableList.copyOf(exprs));
-    }
-
-    /**
-     * Derives the return type of a call to an operator.
-     *
-     * @param op the operator being called
-     * @param exprs actual operands
-     * @return derived type
-     */
-    public RelDataType deriveReturnType(SqlOperator op, List<? extends RexNode> exprs) {
-        return op.inferReturnType(new RexCallBinding(typeFactory, op, exprs, ImmutableList.of()));
-    }
-
-    /**
-     * Creates a reference to an aggregate call, checking for repeated calls.
-     *
-     * <p>Argument types help to optimize for repeated aggregates. For instance count(42) is
-     * equivalent to count(*).
-     *
-     * @param aggCall aggregate call to be added
-     * @param groupCount number of groups in the aggregate relation
-     * @param aggCalls destination list of aggregate calls
-     * @param aggCallMapping the dictionary of already added calls
-     * @param isNullable Whether input field i is nullable
-     * @return Rex expression for the given aggregate call
-     */
-    public RexNode addAggCall(
-            AggregateCall aggCall,
-            int groupCount,
-            List<AggregateCall> aggCalls,
-            Map<AggregateCall, RexNode> aggCallMapping,
-            IntPredicate isNullable) {
-        if (aggCall.getAggregation() instanceof SqlCountAggFunction && !aggCall.isDistinct()) {
-            final List<Integer> args = aggCall.getArgList();
-            final List<Integer> nullableArgs = nullableArgs(args, isNullable);
-            aggCall = aggCall.withArgList(nullableArgs);
-        }
-        RexNode rex = aggCallMapping.get(aggCall);
-        if (rex == null) {
-            int index = aggCalls.size() + groupCount;
-            aggCalls.add(aggCall);
-            rex = makeInputRef(aggCall.getType(), index);
-            aggCallMapping.put(aggCall, rex);
-        }
-        return rex;
-    }
-
-    @Deprecated // to be removed before 2.0
-    public RexNode addAggCall(
-            final AggregateCall aggCall,
-            int groupCount,
-            List<AggregateCall> aggCalls,
-            Map<AggregateCall, RexNode> aggCallMapping,
-            final @Nullable List<RelDataType> aggArgTypes) {
-        return addAggCall(
-                aggCall,
-                groupCount,
-                aggCalls,
-                aggCallMapping,
-                i ->
-                        requireNonNull(aggArgTypes, "aggArgTypes")
-                                .get(aggCall.getArgList().indexOf(i))
-                                .isNullable());
-    }
-
-    /** Creates a reference to an aggregate call, checking for repeated calls. */
-    @Deprecated // to be removed before 2.0
-    public RexNode addAggCall(
-            AggregateCall aggCall,
-            int groupCount,
-            boolean indicator,
-            List<AggregateCall> aggCalls,
-            Map<AggregateCall, RexNode> aggCallMapping,
-            final @Nullable List<RelDataType> aggArgTypes) {
-        checkArgument(!indicator, "indicator is deprecated, use GROUPING function instead");
-        return addAggCall(aggCall, groupCount, aggCalls, aggCallMapping, aggArgTypes);
-    }
-
-    private static List<Integer> nullableArgs(List<Integer> list0, IntPredicate isNullable) {
-        return list0.stream().filter(isNullable::test).collect(toImmutableList());
-    }
-
-    @Deprecated // to be removed before 2.0
-    public RexNode makeOver(
-            RelDataType type,
-            SqlAggFunction operator,
-            List<RexNode> exprs,
-            List<RexNode> partitionKeys,
-            ImmutableList<RexFieldCollation> orderKeys,
-            RexWindowBound lowerBound,
-            RexWindowBound upperBound,
-            boolean rows,
-            boolean allowPartial,
-            boolean nullWhenCountZero,
-            boolean distinct) {
-        return makeOver(
-                type,
-                operator,
-                exprs,
-                partitionKeys,
-                orderKeys,
-                lowerBound,
-                upperBound,
-                rows,
-                allowPartial,
-                nullWhenCountZero,
-                distinct,
-                false);
-    }
-
-    /** Creates a call to a windowed agg. */
-    public RexNode makeOver(
-            RelDataType type,
-            SqlAggFunction operator,
-            List<RexNode> exprs,
-            List<RexNode> partitionKeys,
-            ImmutableList<RexFieldCollation> orderKeys,
-            RexWindowBound lowerBound,
-            RexWindowBound upperBound,
-            boolean rows,
-            boolean allowPartial,
-            boolean nullWhenCountZero,
-            boolean distinct,
-            boolean ignoreNulls) {
-        return makeOver(
-                type,
-                operator,
-                exprs,
-                partitionKeys,
-                orderKeys,
-                lowerBound,
-                upperBound,
-                RexWindowExclusion.EXCLUDE_NO_OTHER,
-                rows,
-                allowPartial,
-                nullWhenCountZero,
-                distinct,
-                ignoreNulls);
-    }
-
-    /** Creates a call to a windowed agg. */
-    public RexNode makeOver(
-            RelDataType type,
-            SqlAggFunction operator,
-            List<RexNode> exprs,
-            List<RexNode> partitionKeys,
-            ImmutableList<RexFieldCollation> orderKeys,
-            RexWindowBound lowerBound,
-            RexWindowBound upperBound,
-            RexWindowExclusion exclude,
-            boolean rows,
-            boolean allowPartial,
-            boolean nullWhenCountZero,
-            boolean distinct,
-            boolean ignoreNulls) {
-        final RexWindow window =
-                makeWindow(partitionKeys, orderKeys, lowerBound, upperBound, rows, exclude);
-        RexNode result = new RexOver(type, operator, exprs, window, distinct, ignoreNulls);
-
-        // This should be correct but need time to go over test results.
-        // Also want to look at combing with section below.
-        if (nullWhenCountZero) {
-            final RelDataType bigintType = typeFactory.createSqlType(SqlTypeName.BIGINT);
-            result =
-                    makeCall(
-                            SqlStdOperatorTable.CASE,
-                            makeCall(
-                                    SqlStdOperatorTable.GREATER_THAN,
-                                    new RexOver(
-                                            bigintType,
-                                            SqlStdOperatorTable.COUNT,
-                                            exprs,
-                                            window,
-                                            distinct,
-                                            ignoreNulls),
-                                    makeLiteral(BigDecimal.ZERO, bigintType, SqlTypeName.DECIMAL)),
-                            ensureType(
-                                    type, // SUM0 is non-nullable, thus need a cast
-                                    new RexOver(
-                                            typeFactory.createTypeWithNullability(type, false),
-                                            operator,
-                                            exprs,
-                                            window,
-                                            distinct,
-                                            ignoreNulls),
-                                    false),
-                            makeNullLiteral(type));
-        }
-        if (!allowPartial) {
-            checkArgument(rows, "DISALLOW PARTIAL over RANGE");
-            final RelDataType bigintType = typeFactory.createSqlType(SqlTypeName.BIGINT);
-            // todo: read bound
-            result =
-                    makeCall(
-                            SqlStdOperatorTable.CASE,
-                            makeCall(
-                                    SqlStdOperatorTable.GREATER_THAN_OR_EQUAL,
-                                    new RexOver(
-                                            bigintType,
-                                            SqlStdOperatorTable.COUNT,
-                                            ImmutableList.of(),
-                                            window,
-                                            distinct,
-                                            ignoreNulls),
-                                    makeLiteral(
-                                            BigDecimal.valueOf(2),
-                                            bigintType,
-                                            SqlTypeName.DECIMAL)),
-                            result,
-                            constantNull);
-        }
-        return result;
-    }
-
-    /**
-     * Creates a window specification.
-     *
-     * @param partitionKeys Partition keys
-     * @param orderKeys Order keys
-     * @param lowerBound Lower bound
-     * @param upperBound Upper bound
-     * @param rows Whether physical. True if row-based, false if range-based
-     * @return window specification
-     */
-    public RexWindow makeWindow(
-            List<RexNode> partitionKeys,
-            ImmutableList<RexFieldCollation> orderKeys,
-            RexWindowBound lowerBound,
-            RexWindowBound upperBound,
-            boolean rows) {
-        return makeWindow(
-                partitionKeys,
-                orderKeys,
-                lowerBound,
-                upperBound,
-                rows,
-                RexWindowExclusion.EXCLUDE_NO_OTHER);
-    }
-
-    /**
-     * Creates a window specification.
-     *
-     * @param partitionKeys Partition keys
-     * @param orderKeys Order keys
-     * @param lowerBound Lower bound
-     * @param upperBound Upper bound
-     * @param rows Whether physical. True if row-based, false if range-based
-     * @return window specification
-     */
-    public RexWindow makeWindow(
-            List<RexNode> partitionKeys,
-            ImmutableList<RexFieldCollation> orderKeys,
-            RexWindowBound lowerBound,
-            RexWindowBound upperBound,
-            boolean rows,
-            RexWindowExclusion exclude) {
-        if (orderKeys.isEmpty() && !rows) {
-            lowerBound = RexWindowBounds.UNBOUNDED_PRECEDING;
-            upperBound = RexWindowBounds.UNBOUNDED_FOLLOWING;
-        }
-        if (lowerBound.isUnboundedPreceding() && upperBound.isUnboundedFollowing()) {
-            // RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
-            //   is equivalent to
-            // ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
-            //   but we prefer "RANGE"
-            rows = false;
-        }
-        return new RexWindow(partitionKeys, orderKeys, lowerBound, upperBound, rows, exclude);
-    }
-
-    /**
-     * Creates a constant for the SQL <code>NULL</code> value.
-     *
-     * @deprecated Use {@link #makeNullLiteral(RelDataType)}, which produces a NULL of the correct
-     *     type
-     */
-    @Deprecated // to be removed before 2.0
-    public RexLiteral constantNull() {
-        return constantNull;
-    }
-
-    /**
-     * Creates an expression referencing a correlation variable.
-     *
-     * @param id Name of variable
-     * @param type Type of variable
-     * @return Correlation variable
-     */
-    public RexNode makeCorrel(RelDataType type, CorrelationId id) {
-        return new RexCorrelVariable(id, type);
-    }
-
-    /**
-     * Creates an invocation of the NEW operator.
-     *
-     * @param type Type to be instantiated
-     * @param exprs Arguments to NEW operator
-     * @return Expression invoking NEW operator
-     */
-    public RexNode makeNewInvocation(RelDataType type, List<RexNode> exprs) {
-        return new RexCall(type, SqlStdOperatorTable.NEW, exprs);
-    }
-
-    /**
-     * Creates a call to the CAST operator.
-     *
-     * @param type Type to cast to
-     * @param exp Expression being cast
-     * @return Call to CAST operator
-     */
-    public RexNode makeCast(RelDataType type, RexNode exp) {
-        return makeCast(type, exp, false, false, constantNull);
-    }
-
-    /**
-     * Creates a call to the CAST operator.
-     *
-     * @param pos Parser position of the cast.
-     * @param type Type to cast to
-     * @param exp Expression being cast
-     * @return Call to CAST operator
-     */
-    public RexNode makeCast(SqlParserPos pos, RelDataType type, RexNode exp) {
-        return makeCast(pos, type, exp, false, false, constantNull);
-    }
-
-    @Deprecated // to be removed before 2.0
-    public RexNode makeCast(RelDataType type, RexNode exp, boolean matchNullability) {
-        return makeCast(type, exp, matchNullability, false, constantNull);
-    }
-
-    /**
-     * Creates a call to the CAST operator, expanding if possible, and optionally also preserving
-     * nullability, and optionally in safe mode.
-     *
-     * <p>Tries to expand the cast, and therefore the result may be something other than a {@link
-     * RexCall} to the CAST operator, such as a {@link RexLiteral}.
-     *
-     * @param pos Parser position
-     * @param type Type to cast to
-     * @param exp Expression being cast
-     * @param matchNullability Whether to ensure the result has the same nullability as {@code type}
-     * @param safe Whether to return NULL if cast fails
-     * @return Call to CAST operator
-     */
-    public RexNode makeCast(
-            SqlParserPos pos,
-            RelDataType type,
-            RexNode exp,
-            boolean matchNullability,
-            boolean safe) {
-        return makeCast(pos, type, exp, matchNullability, safe, constantNull);
-    }
-
-    /**
-     * Creates a call to the CAST operator, expanding if possible, and optionally also preserving
-     * nullability, and optionally in safe mode.
-     *
-     * <p>Tries to expand the cast, and therefore the result may be something other than a {@link
-     * RexCall} to the CAST operator, such as a {@link RexLiteral}.
-     *
-     * @param type Type to cast to
-     * @param exp Expression being cast
-     * @param matchNullability Whether to ensure the result has the same nullability as {@code type}
-     * @param safe Whether to return NULL if cast fails
-     * @return Call to CAST operator
-     */
-    public RexNode makeCast(RelDataType type, RexNode exp, boolean matchNullability, boolean safe) {
-        return makeCast(type, exp, matchNullability, safe, constantNull);
-    }
-
-    /**
-     * Creates a call to the CAST operator, expanding if possible, and optionally also preserving
-     * nullability, and optionally in safe mode.
-     *
-     * <p>Tries to expand the cast, and therefore the result may be something other than a {@link
-     * RexCall} to the CAST operator, such as a {@link RexLiteral}.
-     *
-     * @param type Type to cast to
-     * @param exp Expression being cast
-     * @param matchNullability Whether to ensure the result has the same nullability as {@code type}
-     * @param safe Whether to return NULL if cast fails
-     * @param format Type Format to cast into
-     * @return Call to CAST operator
-     */
-    public RexNode makeCast(
-            RelDataType type,
-            RexNode exp,
-            boolean matchNullability,
-            boolean safe,
-            RexLiteral format) {
-        return makeCast(SqlParserPos.ZERO, type, exp, matchNullability, safe, format);
-    }
-
-    /**
-     * Creates a call to the CAST operator, expanding if possible, and optionally also preserving
-     * nullability, and optionally in safe mode.
-     *
-     * <p>Tries to expand the cast, and therefore the result may be something other than a {@link
-     * RexCall} to the CAST operator, such as a {@link RexLiteral}.
-     *
-     * @param pos Parser position
-     * @param type Type to cast to
-     * @param exp Expression being cast
-     * @param matchNullability Whether to ensure the result has the same nullability as {@code type}
-     * @param safe Whether to return NULL if cast fails
-     * @param format Type Format to cast into
-     * @return Call to CAST operator
-     */
-    public RexNode makeCast(
-            SqlParserPos pos,
-            RelDataType type,
-            RexNode exp,
-            boolean matchNullability,
-            boolean safe,
-            RexLiteral format) {
-        final SqlTypeName sqlType = type.getSqlTypeName();
-        if (exp instanceof RexLiteral) {
-            RexLiteral literal = (RexLiteral) exp;
-            Comparable value = literal.getValueAs(Comparable.class);
-            SqlTypeName typeName = literal.getTypeName();
-
-            // Allow casting boolean literals to integer types.
-            if (exp.getType().getSqlTypeName() == SqlTypeName.BOOLEAN
-                    && SqlTypeUtil.isExactNumeric(type)) {
-                return makeCastBooleanToExact(type, exp);
-            }
-            if (canRemoveCastFromLiteral(type, value, typeName)) {
-                switch (typeName) {
-                    case INTERVAL_YEAR:
-                    case INTERVAL_YEAR_MONTH:
-                    case INTERVAL_MONTH:
-                    case INTERVAL_DAY:
-                    case INTERVAL_DAY_HOUR:
-                    case INTERVAL_DAY_MINUTE:
-                    case INTERVAL_DAY_SECOND:
-                    case INTERVAL_HOUR:
-                    case INTERVAL_HOUR_MINUTE:
-                    case INTERVAL_HOUR_SECOND:
-                    case INTERVAL_MINUTE:
-                    case INTERVAL_MINUTE_SECOND:
-                    case INTERVAL_SECOND:
-                        assert value instanceof BigDecimal;
-                        typeName = type.getSqlTypeName();
-                        switch (typeName) {
-                            case BIGINT:
-                            case INTEGER:
-                            case SMALLINT:
-                            case TINYINT:
-                            case DOUBLE:
-                            case FLOAT:
-                            case REAL:
-                            case DECIMAL:
-                                BigDecimal value2 = (BigDecimal) value;
-                                final BigDecimal multiplier =
-                                        baseUnit(literal.getTypeName()).multiplier;
-                                final BigDecimal divider =
-                                        literal.getTypeName().getEndUnit().multiplier;
-                                value =
-                                        value2.multiply(multiplier)
-                                                .divide(divider, 0, RoundingMode.HALF_DOWN);
-                                break;
-                            default:
-                                break;
-                        }
-
-                        // Not all types are allowed for literals
-                        switch (typeName) {
-                            case INTEGER:
-                                typeName = SqlTypeName.BIGINT;
-                                break;
-                            default:
-                                break;
-                        }
-                        break;
-                    default:
-                        break;
-                }
-                final RexLiteral literal2 = makeLiteral(value, type, typeName);
-                if (type.isNullable() && !literal2.getType().isNullable() && matchNullability) {
-                    return makeAbstractCast(pos, type, literal2, safe, format);
-                }
-                return literal2;
-            }
-        } else if (SqlTypeUtil.isExactNumeric(type) && SqlTypeUtil.isInterval(exp.getType())) {
-            return makeCastIntervalToExact(pos, type, exp);
-        } else if (sqlType == SqlTypeName.BOOLEAN && SqlTypeUtil.isExactNumeric(exp.getType())) {
-            return makeCastExactToBoolean(type, exp);
-        } else if (exp.getType().getSqlTypeName() == SqlTypeName.BOOLEAN
-                && SqlTypeUtil.isExactNumeric(type)) {
-            return makeCastBooleanToExact(type, exp);
-        }
-        return makeAbstractCast(pos, type, exp, safe, format);
-    }
-
-    /**
-     * Returns the lowest granularity unit for the given unit. YEAR and MONTH intervals are stored
-     * as months; HOUR, MINUTE, SECOND intervals are stored as milliseconds.
-     */
-    protected static TimeUnit baseUnit(SqlTypeName unit) {
-        if (unit.isYearMonth()) {
-            return TimeUnit.MONTH;
-        } else {
-            return TimeUnit.MILLISECOND;
-        }
-    }
-
-    boolean canRemoveCastFromLiteral(
-            RelDataType toType,
-            @SuppressWarnings("rawtypes") @Nullable Comparable value,
-            SqlTypeName fromTypeName) {
-        if (value == null) {
-            return true;
-        }
-        final SqlTypeName sqlType = toType.getSqlTypeName();
-        if (sqlType == SqlTypeName.MEASURE) {
-            return false;
-        }
-        if (!RexLiteral.valueMatchesType(value, sqlType, false)) {
-            return false;
-        }
-        if (toType.getSqlTypeName() != fromTypeName
-                && (SqlTypeFamily.DATETIME.getTypeNames().contains(fromTypeName)
-                        || SqlTypeFamily.INTERVAL_DAY_TIME.getTypeNames().contains(fromTypeName)
-                        || SqlTypeFamily.INTERVAL_YEAR_MONTH
-                                .getTypeNames()
-                                .contains(fromTypeName))) {
-            return false;
-        }
-        if (value instanceof NlsString) {
-            final int length = ((NlsString) value).getValue().length();
-            switch (toType.getSqlTypeName()) {
-                case CHAR:
-                    return SqlTypeUtil.comparePrecision(toType.getPrecision(), length) == 0;
-                case VARCHAR:
-                    return SqlTypeUtil.comparePrecision(toType.getPrecision(), length) >= 0;
-                default:
-                    throw new AssertionError(toType);
-            }
-        }
-        if (value instanceof ByteString) {
-            final int length = ((ByteString) value).length();
-            switch (toType.getSqlTypeName()) {
-                case BINARY:
-                    return SqlTypeUtil.comparePrecision(toType.getPrecision(), length) == 0;
-                case VARBINARY:
-                    return SqlTypeUtil.comparePrecision(toType.getPrecision(), length) >= 0;
-                default:
-                    throw new AssertionError(toType);
-            }
-        }
-
-        if (toType.getSqlTypeName() == SqlTypeName.DECIMAL
-                && fromTypeName.getFamily() == SqlTypeFamily.NUMERIC) {
-            final BigDecimal decimalValue = (BigDecimal) value;
-            return SqlTypeUtil.canBeRepresentedExactly(decimalValue, toType);
-        }
-
-        if (SqlTypeName.INT_TYPES.contains(sqlType)) {
-            final BigDecimal decimalValue = (BigDecimal) value;
-            try {
-                // Will throw ArithmeticException if the value cannot be represented using a 'long'
-                long l = decimalValue.longValueExact();
-                switch (sqlType) {
-                    case TINYINT:
-                        return l >= Byte.MIN_VALUE && l <= Byte.MAX_VALUE;
-                    case SMALLINT:
-                        return l >= Short.MIN_VALUE && l <= Short.MAX_VALUE;
-                    case INTEGER:
-                        return l >= Integer.MIN_VALUE && l <= Integer.MAX_VALUE;
-                    case BIGINT:
-                    default:
-                        return true;
-                }
-            } catch (ArithmeticException ex) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    private RexNode makeCastExactToBoolean(RelDataType toType, RexNode exp) {
-        return makeCall(
-                toType,
-                SqlStdOperatorTable.NOT_EQUALS,
-                ImmutableList.of(exp, makeZeroLiteral(exp.getType())));
-    }
-
-    private RexNode makeCastBooleanToExact(RelDataType toType, RexNode exp) {
-        final RexNode casted =
-                makeCall(
-                        SqlStdOperatorTable.CASE,
-                        exp,
-                        makeExactLiteral(BigDecimal.ONE, toType),
-                        makeZeroLiteral(toType));
-        if (!exp.getType().isNullable()) {
-            return casted;
-        }
-        return makeCall(
-                toType,
-                SqlStdOperatorTable.CASE,
-                ImmutableList.of(
-                        makeCall(SqlStdOperatorTable.IS_NOT_NULL, exp),
-                        casted,
-                        makeNullLiteral(toType)));
-    }
-
-    private RexNode makeCastIntervalToExact(SqlParserPos pos, RelDataType toType, RexNode exp) {
-        final TimeUnit endUnit = exp.getType().getSqlTypeName().getEndUnit();
-        final TimeUnit baseUnit = baseUnit(exp.getType().getSqlTypeName());
-        final BigDecimal multiplier = baseUnit.multiplier;
-        final BigDecimal divider = endUnit.multiplier;
-        RexNode value = multiplyDivide(pos, decodeIntervalOrDecimal(pos, exp), multiplier, divider);
-        return ensureType(pos, toType, value, false);
-    }
-
-    public RexNode multiplyDivide(RexNode e, BigDecimal multiplier, BigDecimal divider) {
-        return multiplyDivide(SqlParserPos.ZERO, e, multiplier, divider);
-    }
-
-    public RexNode multiplyDivide(
-            SqlParserPos pos, RexNode e, BigDecimal multiplier, BigDecimal divider) {
-        assert multiplier.signum() > 0;
-        assert divider.signum() > 0;
-        switch (multiplier.compareTo(divider)) {
-            case 0:
-                return e;
-            case 1:
-                // E.g. multiplyDivide(e, 1000, 10) ==> e * 100
-                return makeCall(
-                        pos,
-                        SqlStdOperatorTable.MULTIPLY,
-                        e,
-                        makeExactLiteral(multiplier.divide(divider, RoundingMode.UNNECESSARY)));
-            case -1:
-                // E.g. multiplyDivide(e, 10, 1000) ==> e / 100
-                return makeCall(
-                        pos,
-                        SqlStdOperatorTable.DIVIDE_INTEGER,
-                        e,
-                        makeExactLiteral(divider.divide(multiplier, RoundingMode.UNNECESSARY)));
-            default:
-                throw new AssertionError(multiplier + "/" + divider);
-        }
-    }
-
-    /**
-     * Casts a decimal's integer representation to a decimal node. If the expression is not the
-     * expected integer type, then it is casted first.
-     *
-     * <p>An overflow check may be requested to ensure the internal value does not exceed the
-     * maximum value of the decimal type.
-     *
-     * @param value integer representation of decimal
-     * @param type type integer will be reinterpreted as
-     * @param checkOverflow indicates whether an overflow check is required when reinterpreting this
-     *     particular value as the decimal type. A check usually not required for arithmetic, but is
-     *     often required for rounding and explicit casts.
-     * @return the integer reinterpreted as an opaque decimal type
-     */
-    public RexNode encodeIntervalOrDecimal(RexNode value, RelDataType type, boolean checkOverflow) {
-        return encodeIntervalOrDecimal(SqlParserPos.ZERO, value, type, checkOverflow);
-    }
-
-    public RexNode encodeIntervalOrDecimal(
-            SqlParserPos pos, RexNode value, RelDataType type, boolean checkOverflow) {
-        RelDataType bigintType = typeFactory.createSqlType(SqlTypeName.BIGINT);
-        RexNode cast = ensureType(pos, bigintType, value, true);
-        return makeReinterpretCast(pos, type, cast, makeLiteral(checkOverflow));
-    }
-
-    /**
-     * Retrieves an INTERVAL or DECIMAL node's integer representation.
-     *
-     * @param node the interval or decimal value as an opaque type
-     * @return an integer representation of the decimal value
-     */
-    public RexNode decodeIntervalOrDecimal(RexNode node) {
-        return decodeIntervalOrDecimal(SqlParserPos.ZERO, node);
-    }
-
-    public RexNode decodeIntervalOrDecimal(SqlParserPos pos, RexNode node) {
-        assert SqlTypeUtil.isDecimal(node.getType()) || SqlTypeUtil.isInterval(node.getType());
-        RelDataType bigintType = typeFactory.createSqlType(SqlTypeName.BIGINT);
-        return makeReinterpretCast(
-                pos, matchNullability(bigintType, node), node, makeLiteral(false));
-    }
-
-    @Deprecated // to be removed before 2.0
-    public RexNode makeAbstractCast(RelDataType type, RexNode exp) {
-        return makeAbstractCast(type, exp, false);
-    }
-
-    /**
-     * Creates a call to CAST or SAFE_CAST operator.
-     *
-     * @param type Type to cast to
-     * @param exp Expression being cast
-     * @param safe Whether to return NULL if cast fails
-     * @return Call to CAST operator
-     */
-    public RexNode makeAbstractCast(RelDataType type, RexNode exp, boolean safe) {
-        return makeAbstractCast(SqlParserPos.ZERO, type, exp, safe);
-    }
-
-    /**
-     * Creates a call to CAST or SAFE_CAST operator.
-     *
-     * @param pos Parser position.
-     * @param type Type to cast to
-     * @param exp Expression being cast
-     * @param safe Whether to return NULL if cast fails
-     * @return Call to CAST operator Casts can fail at runtime, so we expect position information.
-     */
-    public RexNode makeAbstractCast(SqlParserPos pos, RelDataType type, RexNode exp, boolean safe) {
-        final SqlOperator operator =
-                safe ? SqlLibraryOperators.SAFE_CAST : SqlStdOperatorTable.CAST;
-        return new RexCall(pos, type, operator, ImmutableList.of(exp));
-    }
-
-    /**
-     * Creates a call to CAST or SAFE_CAST operator with a FORMAT clause.
-     *
-     * @param type Type to cast to
-     * @param exp Expression being cast
-     * @param safe Whether to return NULL if cast fails
-     * @param format Conversion format for target type
-     * @return Call to CAST operator
-     */
-    public RexNode makeAbstractCast(
-            RelDataType type, RexNode exp, boolean safe, RexLiteral format) {
-        return makeAbstractCast(SqlParserPos.ZERO, type, exp, safe, format);
-    }
-
-    /**
-     * Creates a call to CAST or SAFE_CAST operator with a FORMAT clause.
-     *
-     * @param pos Parser position
-     * @param type Type to cast to
-     * @param exp Expression being cast
-     * @param safe Whether to return NULL if cast fails
-     * @param format Conversion format for target type
-     * @return Call to CAST operator
-     */
-    public RexNode makeAbstractCast(
-            SqlParserPos pos, RelDataType type, RexNode exp, boolean safe, RexLiteral format) {
-        final SqlOperator operator =
-                safe ? SqlLibraryOperators.SAFE_CAST : SqlStdOperatorTable.CAST;
-        if (format.isNull()) {
-            return new RexCall(pos, type, operator, ImmutableList.of(exp));
-        }
-        return new RexCall(pos, type, operator, ImmutableList.of(exp, format));
-    }
-
-    /**
-     * Makes a reinterpret cast.
-     *
-     * @param type type returned by the cast
-     * @param exp expression to be casted
-     * @param checkOverflow whether an overflow check is required
-     * @return a RexCall with two operands and a special return type
-     */
-    public RexNode makeReinterpretCast(RelDataType type, RexNode exp, RexNode checkOverflow) {
-        return makeReinterpretCast(SqlParserPos.ZERO, type, exp, checkOverflow);
-    }
-
-    /**
-     * Makes a reinterpret cast.
-     *
-     * @param pos parser position
-     * @param type type returned by the cast
-     * @param exp expression to be cast
-     * @param checkOverflow whether an overflow check is required
-     * @return a RexCall with two operands and a special return type
-     */
-    public RexNode makeReinterpretCast(
-            SqlParserPos pos, RelDataType type, RexNode exp, RexNode checkOverflow) {
-        List<RexNode> args;
-        if (checkOverflow.isAlwaysTrue()) {
-            args = ImmutableList.of(exp, checkOverflow);
-        } else {
-            args = ImmutableList.of(exp);
-        }
-        return new RexCall(pos, type, SqlStdOperatorTable.REINTERPRET, args);
-    }
-
-    /**
-     * Makes a cast of an expression to nullable; returns the expression unchanged if its type is
-     * already nullable.
-     */
-    public RexNode makeNullable(RexNode exp) {
-        return makeNullable(exp, true);
-    }
-
-    /**
-     * Makes a cast of an expression to NOT NULL; returns the expression unchanged if its type
-     * already has NOT NULL.
-     */
-    public RexNode makeNotNull(RexNode exp) {
-        return makeNullable(exp, false);
-    }
-
-    /**
-     * Makes a cast of an expression to the required nullability; returns the expression unchanged
-     * if its type already has the desired nullability.
-     */
-    public RexNode makeNullable(RexNode exp, boolean nullability) {
-        final RelDataType type = exp.getType();
-        if (type.isNullable() == nullability) {
-            return exp;
-        }
-        final RelDataType type2 = typeFactory.createTypeWithNullability(type, nullability);
-        return makeAbstractCast(SqlParserPos.ZERO, type2, exp, false);
-    }
-
-    /**
-     * Creates a reference to all the fields in the row. That is, the whole row as a single record
-     * object.
-     *
-     * @param input Input relational expression
-     */
-    public RexNode makeRangeReference(RelNode input) {
-        return new RexRangeRef(input.getRowType(), 0);
-    }
-
-    /**
-     * Creates a reference to all the fields in the row.
-     *
-     * <p>For example, if the input row has type <code>T{f0,f1,f2,f3,f4}</code> then <code>
-     * makeRangeReference(T{f0,f1,f2,f3,f4}, S{f3,f4}, 3)</code> is an expression which yields the
-     * last 2 fields.
-     *
-     * @param type Type of the resulting range record.
-     * @param offset Index of first field.
-     * @param nullable Whether the record is nullable.
-     */
-    public RexRangeRef makeRangeReference(RelDataType type, int offset, boolean nullable) {
-        if (nullable && !type.isNullable()) {
-            type = typeFactory.createTypeWithNullability(type, nullable);
-        }
-        return new RexRangeRef(type, offset);
-    }
-
-    /**
-     * Creates a reference to a given field of the input record.
-     *
-     * @param type Type of field
-     * @param i Ordinal of field
-     * @return Reference to field
-     */
-    public RexInputRef makeInputRef(RelDataType type, int i) {
-        type = SqlTypeUtil.addCharsetAndCollation(type, typeFactory);
-        return new RexInputRef(i, type);
-    }
-
-    /**
-     * Creates a reference to a given field of the input relational expression.
-     *
-     * @param input Input relational expression
-     * @param i Ordinal of field
-     * @return Reference to field
-     * @see #identityProjects(RelDataType)
-     */
-    public RexInputRef makeInputRef(RelNode input, int i) {
-        return makeInputRef(input.getRowType().getFieldList().get(i).getType(), i);
-    }
-
-    /**
-     * Creates a reference to a given field of the pattern.
-     *
-     * @param alpha the pattern name
-     * @param type Type of field
-     * @param i Ordinal of field
-     * @return Reference to field of pattern
-     */
-    public RexPatternFieldRef makePatternFieldRef(String alpha, RelDataType type, int i) {
-        type = SqlTypeUtil.addCharsetAndCollation(type, typeFactory);
-        return new RexPatternFieldRef(alpha, i, type);
-    }
-
-    /**
-     * Create a reference to local variable.
-     *
-     * @param type Type of variable
-     * @param i Ordinal of variable
-     * @return Reference to local variable
-     */
-    public RexLocalRef makeLocalRef(RelDataType type, int i) {
-        type = SqlTypeUtil.addCharsetAndCollation(type, typeFactory);
-        return new RexLocalRef(i, type);
-    }
-
-    /**
-     * Creates a literal representing a flag.
-     *
-     * @param flag Flag value
-     */
-    public RexLiteral makeFlag(Enum flag) {
-        return makeLiteral(
-                requireNonNull(flag, "flag"),
-                typeFactory.createSqlType(SqlTypeName.SYMBOL),
-                SqlTypeName.SYMBOL);
-    }
-
-    /**
-     * Internal method to create a call to a literal. Code outside this package should call one of
-     * the type-specific methods such as {@link #makeDateLiteral(DateString)}, {@link
-     * #makeLiteral(boolean)}, {@link #makeLiteral(String)}.
-     *
-     * @param o Value of literal, must be appropriate for the type
-     * @param type Type of literal
-     * @param typeName SQL type of literal
-     * @return Literal
-     */
-    protected RexLiteral makeLiteral(
-            @Nullable Comparable o, RelDataType type, SqlTypeName typeName) {
-        // All literals except NULL have NOT NULL types.
-        type = typeFactory.createTypeWithNullability(type, o == null);
-        int p;
-        switch (typeName) {
-            case CHAR:
-                // Character literals must have a charset and collation. Populate
-                // from the type if necessary.
-                assert o instanceof NlsString;
-                NlsString nlsString = (NlsString) o;
-                if (nlsString.getCollation() == null
-                        || nlsString.getCharset() == null
-                        || !Objects.equals(nlsString.getCharset(), type.getCharset())
-                        || !Objects.equals(nlsString.getCollation(), type.getCollation())) {
-                    assert type.getSqlTypeName() == SqlTypeName.CHAR
-                            || type.getSqlTypeName() == SqlTypeName.VARCHAR;
-                    Charset charset = requireNonNull(type.getCharset(), "type.getCharset()");
-                    final SqlCollation collation =
-                            requireNonNull(type.getCollation(), "type.getCollation()");
-                    o = new NlsString(nlsString.getValue(), charset.name(), collation);
-                }
-                break;
-            case TIME:
-            case TIME_WITH_LOCAL_TIME_ZONE:
-                assert o instanceof TimeString;
-                p = type.getPrecision();
-                if (p == RelDataType.PRECISION_NOT_SPECIFIED) {
-                    p = 0;
-                }
-                o = ((TimeString) o).round(p);
-                break;
-            case TIME_TZ:
-                assert o instanceof TimeWithTimeZoneString;
-                p = type.getPrecision();
-                if (p == RelDataType.PRECISION_NOT_SPECIFIED) {
-                    p = 0;
-                }
-                o = ((TimeWithTimeZoneString) o).round(p);
-                break;
-            case TIMESTAMP:
-            case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-                assert o instanceof TimestampString;
-                p = type.getPrecision();
-                if (p == RelDataType.PRECISION_NOT_SPECIFIED) {
-                    p = 0;
-                }
-                o = ((TimestampString) o).round(p);
-                break;
-            case TIMESTAMP_TZ:
-                assert o instanceof TimestampWithTimeZoneString;
-                p = type.getPrecision();
-                if (p == RelDataType.PRECISION_NOT_SPECIFIED) {
-                    p = 0;
-                }
-                o = ((TimestampWithTimeZoneString) o).round(p);
-                break;
-            case DECIMAL:
-                if (o != null && type.getScale() != RelDataType.SCALE_NOT_SPECIFIED) {
-                    assert o instanceof BigDecimal;
-                    o =
-                            ((BigDecimal) o)
-                                    .setScale(
-                                            type.getScale(),
-                                            typeFactory.getTypeSystem().roundingMode());
-                    if (type.getScale() < 0) {
-                        o = new BigDecimal(((BigDecimal) o).toPlainString());
-                    }
-                }
-                break;
-            default:
-                break;
-        }
-        if (typeName == SqlTypeName.DECIMAL
-                && !SqlTypeUtil.isValidDecimalValue((BigDecimal) o, type)) {
-            throw new IllegalArgumentException(
-                    "Cannot convert " + o + " to " + type + " due to overflow");
-        }
-        return new RexLiteral(o, type, typeName);
-    }
-
-    /** Creates a boolean literal. */
-    public RexLiteral makeLiteral(boolean b) {
-        return b ? booleanTrue : booleanFalse;
-    }
-
-    /** Creates a numeric literal. */
-    @SuppressWarnings("deprecation") // [CALCITE-6598]
-    public RexLiteral makeExactLiteral(BigDecimal bd) {
-        RelDataType relType;
-        int scale = bd.scale();
-        assert scale >= 0;
-        assert scale <= typeFactory.getTypeSystem().getMaxNumericScale() : scale;
-        if (scale == 0) {
-            if (bd.compareTo(INT_MIN) >= 0 && bd.compareTo(INT_MAX) <= 0) {
-                relType = typeFactory.createSqlType(SqlTypeName.INTEGER);
-            } else {
-                relType = typeFactory.createSqlType(SqlTypeName.BIGINT);
-            }
-        } else {
-            int precision = bd.unscaledValue().abs().toString().length();
-            if (precision > scale) {
-                // bd is greater than or equal to 1
-                relType = typeFactory.createSqlType(SqlTypeName.DECIMAL, precision, scale);
-            } else {
-                // bd is less than 1
-                relType = typeFactory.createSqlType(SqlTypeName.DECIMAL, scale + 1, scale);
-            }
-        }
-        return makeExactLiteral(bd, relType);
-    }
-
-    /** Creates a BIGINT literal. */
-    public RexLiteral makeBigintLiteral(@Nullable BigDecimal bd) {
-        RelDataType bigintType = typeFactory.createSqlType(SqlTypeName.BIGINT);
-        return makeLiteral(bd, bigintType, SqlTypeName.DECIMAL);
-    }
-
-    /** Creates a numeric literal. */
-    public RexLiteral makeExactLiteral(@Nullable BigDecimal bd, RelDataType type) {
-        return makeLiteral(bd, type, SqlTypeName.DECIMAL);
-    }
-
-    /** Creates a byte array literal. */
-    public RexLiteral makeBinaryLiteral(ByteString byteString) {
-        return makeLiteral(
-                byteString,
-                typeFactory.createSqlType(SqlTypeName.BINARY, byteString.length()),
-                SqlTypeName.BINARY);
-    }
-
-    /** Creates a double-precision literal. */
-    public RexLiteral makeApproxLiteral(BigDecimal bd) {
-        // Validator should catch if underflow is allowed
-        // If underflow is allowed, let underflow become zero
-        if (bd.doubleValue() == 0) {
-            bd = BigDecimal.ZERO;
-        }
-        return makeApproxLiteral(bd, typeFactory.createSqlType(SqlTypeName.DOUBLE));
-    }
-
-    /**
-     * Creates an approximate numeric literal (double or float).
-     *
-     * @param bd literal value
-     * @param type approximate numeric type
-     * @return new literal
-     */
-    public RexLiteral makeApproxLiteral(@Nullable BigDecimal bd, RelDataType type) {
-        assert SqlTypeFamily.APPROXIMATE_NUMERIC.getTypeNames().contains(type.getSqlTypeName());
-        return makeLiteral(bd != null ? bd.doubleValue() : null, type, SqlTypeName.DOUBLE);
-    }
-
-    /**
-     * Creates an approximate numeric literal (double or float) from a Double value.
-     *
-     * @param val literal value
-     * @param type approximate numeric type
-     * @return new literal
-     */
-    public RexLiteral makeApproxLiteral(Double val, RelDataType type) {
-        assert SqlTypeFamily.APPROXIMATE_NUMERIC.getTypeNames().contains(type.getSqlTypeName());
-        return makeLiteral(val, type, SqlTypeName.DOUBLE);
-    }
-
-    /** Creates a search argument literal. */
-    public RexLiteral makeSearchArgumentLiteral(Sarg s, RelDataType type) {
-        return makeLiteral(requireNonNull(s, "s"), type, SqlTypeName.SARG);
-    }
-
-    /** Creates a character string literal. */
-    public RexLiteral makeLiteral(String s) {
-        return makePreciseStringLiteral(requireNonNull(s, "s"));
-    }
-
-    /**
-     * Creates a character string literal with type CHAR and default charset and collation.
-     *
-     * @param s String value
-     * @return Character string literal
-     */
-    protected RexLiteral makePreciseStringLiteral(String s) {
-        if (s.isEmpty()) {
-            return charEmpty;
-        }
-        return makeCharLiteral(new NlsString(s, null, null));
-    }
-
-    /**
-     * Creates a character string literal with type CHAR.
-     *
-     * @param value String value in bytes
-     * @param charsetName SQL-level charset name
-     * @param collation Sql collation
-     * @return String literal
-     */
-    protected RexLiteral makePreciseStringLiteral(
-            ByteString value, String charsetName, SqlCollation collation) {
-        return makeCharLiteral(new NlsString(value, charsetName, collation));
-    }
-
-    /**
-     * Ensures expression is interpreted as a specified type. The returned expression may be wrapped
-     * with a cast.
-     *
-     * @param type desired type
-     * @param node expression
-     * @param matchNullability whether to correct nullability of specified type to match the
-     *     expression; this usually should be true, except for explicit casts which can override
-     *     default nullability
-     * @return a casted expression or the original expression
-     */
-    public RexNode ensureType(RelDataType type, RexNode node, boolean matchNullability) {
-        return ensureType(SqlParserPos.ZERO, type, node, matchNullability);
-    }
-
-    /**
-     * Ensures expression is interpreted as a specified type. The returned expression may be wrapped
-     * with a cast.
-     *
-     * @param pos parser position
-     * @param type desired type
-     * @param node expression
-     * @param matchNullability whether to correct nullability of specified type to match the
-     *     expression; this usually should be true, except for explicit casts which can override
-     *     default nullability
-     * @return a casted expression or the original expression
-     */
-    public RexNode ensureType(
-            SqlParserPos pos, RelDataType type, RexNode node, boolean matchNullability) {
-        RelDataType targetType = type;
-        if (matchNullability) {
-            targetType = matchNullability(type, node);
-        }
-
-        if (targetType.getSqlTypeName() == SqlTypeName.ANY
-                && (!matchNullability || targetType.isNullable() == node.getType().isNullable())) {
-            return node;
-        }
-
-        if (!node.getType().equals(targetType)) {
-            return makeCast(pos, targetType, node);
-        }
-        return node;
-    }
-
-    /** Ensures that a type's nullability matches a value's nullability. */
-    public RelDataType matchNullability(RelDataType type, RexNode value) {
-        boolean typeNullability = type.isNullable();
-        boolean valueNullability = value.getType().isNullable();
-        if (typeNullability != valueNullability) {
-            return typeFactory.createTypeWithNullability(type, valueNullability);
-        }
-        return type;
-    }
-
-    /**
-     * Creates a character string literal from an {@link NlsString}.
-     *
-     * <p>If the string's charset and collation are not set, uses the system defaults.
-     */
-    public RexLiteral makeCharLiteral(NlsString str) {
-        RelDataType type = SqlUtil.createNlsStringType(typeFactory, str);
-        return makeLiteral(str, type, SqlTypeName.CHAR);
-    }
-
-    // CHECKSTYLE: IGNORE 1
-    /**
-     * @deprecated Use {@link #makeDateLiteral(DateString)}.
-     */
-    @Deprecated // to be removed before 2.0
-    public RexLiteral makeDateLiteral(Calendar calendar) {
-        return makeDateLiteral(DateString.fromCalendarFields(calendar));
-    }
-
-    /** Creates a Date literal. */
-    public RexLiteral makeDateLiteral(DateString date) {
-        return makeLiteral(
-                requireNonNull(date, "date"),
-                typeFactory.createSqlType(SqlTypeName.DATE),
-                SqlTypeName.DATE);
-    }
-
-    // CHECKSTYLE: IGNORE 1
-    /**
-     * @deprecated Use {@link #makeTimeLiteral(TimeString, int)}.
-     */
-    @Deprecated // to be removed before 2.0
-    public RexLiteral makeTimeLiteral(Calendar calendar, int precision) {
-        return makeTimeLiteral(TimeString.fromCalendarFields(calendar), precision);
-    }
-
-    /** Creates a Time literal. */
-    public RexLiteral makeTimeLiteral(TimeString time, int precision) {
-        return makeLiteral(
-                requireNonNull(time, "time"),
-                typeFactory.createSqlType(SqlTypeName.TIME, precision),
-                SqlTypeName.TIME);
-    }
-
-    /** Creates a Time with local time-zone literal. */
-    public RexLiteral makeTimeWithLocalTimeZoneLiteral(TimeString time, int precision) {
-        return makeLiteral(
-                requireNonNull(time, "time"),
-                typeFactory.createSqlType(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE, precision),
-                SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE);
-    }
-
-    /** Creates a Time with time-zone literal. */
-    public RexLiteral makeTimeTzLiteral(TimeWithTimeZoneString time, int precision) {
-        return makeLiteral(
-                requireNonNull(time, "time"),
-                typeFactory.createSqlType(SqlTypeName.TIME_TZ, precision),
-                SqlTypeName.TIME_TZ);
-    }
-
-    // CHECKSTYLE: IGNORE 1
-    /**
-     * @deprecated Use {@link #makeTimestampLiteral(TimestampString, int)}.
-     */
-    @Deprecated // to be removed before 2.0
-    public RexLiteral makeTimestampLiteral(Calendar calendar, int precision) {
-        return makeTimestampLiteral(TimestampString.fromCalendarFields(calendar), precision);
-    }
-
-    /** Creates a Timestamp literal. */
-    public RexLiteral makeTimestampLiteral(TimestampString timestamp, int precision) {
-        return makeLiteral(
-                requireNonNull(timestamp, "timestamp"),
-                typeFactory.createSqlType(SqlTypeName.TIMESTAMP, precision),
-                SqlTypeName.TIMESTAMP);
-    }
-
-    /** Creates a Timestamp with local time-zone literal. */
-    public RexLiteral makeTimestampWithLocalTimeZoneLiteral(
-            TimestampString timestamp, int precision) {
-        return makeLiteral(
-                requireNonNull(timestamp, "timestamp"),
-                typeFactory.createSqlType(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE, precision),
-                SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
-    }
-
-    public RexLiteral makeTimestampTzLiteral(TimestampWithTimeZoneString timestamp, int precision) {
-        return makeLiteral(
-                requireNonNull(timestamp, "timestamp"),
-                typeFactory.createSqlType(SqlTypeName.TIMESTAMP_TZ, precision),
-                SqlTypeName.TIMESTAMP_TZ);
-    }
-
-    /**
-     * Creates a literal representing an interval type, for example {@code YEAR TO MONTH} or {@code
-     * DOW}.
-     */
-    public RexLiteral makeIntervalLiteral(SqlIntervalQualifier intervalQualifier) {
-        verifyNotNull(intervalQualifier);
-        if (intervalQualifier.timeFrameName != null) {
-            return makePreciseStringLiteral(intervalQualifier.timeFrameName);
-        }
-        return makeFlag(intervalQualifier.timeUnitRange);
-    }
-
-    /**
-     * Creates a literal representing an interval value, for example {@code INTERVAL '3-7' YEAR TO
-     * MONTH}.
-     */
-    public RexLiteral makeIntervalLiteral(
-            @Nullable BigDecimal v, SqlIntervalQualifier intervalQualifier) {
-        return makeLiteral(
-                v,
-                typeFactory.createSqlIntervalType(intervalQualifier),
-                intervalQualifier.typeName());
-    }
-
-    /**
-     * Creates a reference to a dynamic parameter.
-     *
-     * @param type Type of dynamic parameter
-     * @param index Index of dynamic parameter
-     * @return Expression referencing dynamic parameter
-     */
-    public RexDynamicParam makeDynamicParam(RelDataType type, int index) {
-        return new RexDynamicParam(type, index);
-    }
-
-    /**
-     * Creates a literal whose value is NULL, with a particular type.
-     *
-     * <p>The typing is necessary because RexNodes are strictly typed. For example, in the Rex world
-     * the <code>NULL</code> parameter to <code>
-     * SUBSTRING(NULL FROM 2 FOR 4)</code> must have a valid VARCHAR type so that the result type
-     * can be determined.
-     *
-     * @param type Type to cast NULL to
-     * @return NULL literal of given type
-     */
-    public RexLiteral makeNullLiteral(RelDataType type) {
-        if (!type.isNullable()) {
-            type = typeFactory.createTypeWithNullability(type, true);
-        }
-        return (RexLiteral) makeCast(type, constantNull);
-    }
-
-    // CHECKSTYLE: IGNORE 1
-    /**
-     * @deprecated Use {@link #makeNullLiteral(RelDataType)}
-     */
-    @Deprecated // to be removed before 2.0
-    public RexNode makeNullLiteral(SqlTypeName typeName, int precision) {
-        return makeNullLiteral(typeFactory.createSqlType(typeName, precision));
-    }
-
-    // CHECKSTYLE: IGNORE 1
-    /**
-     * @deprecated Use {@link #makeNullLiteral(RelDataType)}
-     */
-    @Deprecated // to be removed before 2.0
-    public RexNode makeNullLiteral(SqlTypeName typeName) {
-        return makeNullLiteral(typeFactory.createSqlType(typeName));
-    }
-
-    /**
-     * Creates a {@link RexNode} representation a SQL "arg IN (point, ...)" expression.
-     *
-     * <p>If all of the expressions are literals, creates a call {@link Sarg} literal, "SEARCH(arg,
-     * SARG([point0..point0], [point1..point1], ...)"; otherwise creates a disjunction, "arg =
-     * point0 OR arg = point1 OR ...".
-     */
-    public RexNode makeIn(RexNode arg, List<? extends RexNode> ranges) {
-        if (areAssignable(arg, ranges)) {
-            final Sarg sarg = toSarg(Comparable.class, ranges, RexUnknownAs.UNKNOWN);
-            if (sarg != null) {
-                final List<RelDataType> types =
-                        ranges.stream().map(RexNode::getType).collect(Collectors.toList());
-                RelDataType sargType =
-                        requireNonNull(
-                                typeFactory.leastRestrictive(types),
-                                () -> "Can't find leastRestrictive type for SARG among " + types);
-                return makeCall(
-                        SqlStdOperatorTable.SEARCH, arg, makeSearchArgumentLiteral(sarg, sargType));
-            }
-        }
-        return RexUtil.composeDisjunction(
-                this,
-                ranges.stream()
-                        .map(r -> makeCall(SqlStdOperatorTable.EQUALS, arg, r))
-                        .collect(toImmutableList()));
-    }
-
-    /**
-     * Returns whether and argument and bounds are have types that are sufficiently compatible to be
-     * converted to a {@link Sarg}.
-     */
-    private static boolean areAssignable(RexNode arg, List<? extends RexNode> bounds) {
-        for (RexNode bound : bounds) {
-            if (!SqlTypeUtil.inSameFamily(arg.getType(), bound.getType())
-                    && !(arg.getType().isStruct() && bound.getType().isStruct())) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Creates a {@link RexNode} representation a SQL "arg BETWEEN lower AND upper" expression.
-     *
-     * <p>If the expressions are all literals of compatible type, creates a call to {@link Sarg}
-     * literal, {@code SEARCH(arg, SARG([lower..upper])}; otherwise creates a disjunction, {@code
-     * arg >= lower AND arg <= upper}.
-     */
-    public RexNode makeBetween(RexNode arg, RexNode lower, RexNode upper) {
-        final Comparable lowerValue = toComparable(Comparable.class, lower);
-        final Comparable upperValue = toComparable(Comparable.class, upper);
-        if (lowerValue != null
-                && upperValue != null
-                && areAssignable(arg, Arrays.asList(lower, upper))) {
-            final Sarg sarg =
-                    Sarg.of(
-                            RexUnknownAs.UNKNOWN,
-                            ImmutableRangeSet.<Comparable>of(Range.closed(lowerValue, upperValue)));
-            List<RelDataType> types = ImmutableList.of(lower.getType(), upper.getType());
-            RelDataType sargType =
-                    requireNonNull(
-                            typeFactory.leastRestrictive(types),
-                            () -> "Can't find leastRestrictive type for SARG among " + types);
-            return makeCall(
-                    SqlStdOperatorTable.SEARCH, arg, makeSearchArgumentLiteral(sarg, sargType));
-        }
-        return makeCall(
-                SqlStdOperatorTable.AND,
-                makeCall(SqlStdOperatorTable.GREATER_THAN_OR_EQUAL, arg, lower),
-                makeCall(SqlStdOperatorTable.LESS_THAN_OR_EQUAL, arg, upper));
-    }
-
-    /** Converts a list of expressions to a search argument, or returns null if not possible. */
-    private static <C extends Comparable<C>> @Nullable Sarg<C> toSarg(
-            Class<C> clazz, List<? extends RexNode> ranges, RexUnknownAs unknownAs) {
-        if (ranges.isEmpty()) {
-            // Cannot convert an empty list to a Sarg (by this interface, at least)
-            // because we use the type of the first element.
-            return null;
-        }
-        final RangeSet<C> rangeSet = TreeRangeSet.create();
-        for (RexNode range : ranges) {
-            final C value = toComparable(clazz, range);
-            if (value == null) {
-                return null;
-            }
-            rangeSet.add(Range.singleton(value));
-        }
-        return Sarg.of(unknownAs, rangeSet);
-    }
-
-    private static <C extends Comparable<C>> @Nullable C toComparable(
-            Class<C> clazz, RexNode point) {
-        switch (point.getKind()) {
-            case LITERAL:
-                final RexLiteral literal = (RexLiteral) point;
-                return literal.getValueAs(clazz);
-
-            case ROW:
-                final RexCall call = (RexCall) point;
-                final ImmutableList.Builder<Comparable> b = ImmutableList.builder();
-                for (RexNode operand : call.operands) {
-                    //noinspection unchecked
-                    final Comparable value = toComparable(Comparable.class, operand);
-                    if (value == null) {
-                        return null; // not a constant value
-                    }
-                    b.add(value);
-                }
-                return clazz.cast(FlatLists.ofComparable(b.build()));
-
-            default:
-                return null; // not a constant value
-        }
-    }
-
-    /**
-     * Creates a copy of an expression, which may have been created using a different RexBuilder
-     * and/or {@link RelDataTypeFactory}, using this RexBuilder.
-     *
-     * @param expr Expression
-     * @return Copy of expression
-     * @see RelDataTypeFactory#copyType(RelDataType)
-     */
-    public RexNode copy(RexNode expr) {
-        return expr.accept(new RexCopier(this));
-    }
-
-    /**
-     * Creates a literal of the default value for the given type.
-     *
-     * <p>This value is:
-     *
-     * <ul>
-     *   <li>0 for numeric types;
-     *   <li>FALSE for BOOLEAN;
-     *   <li>The epoch for TIMESTAMP and DATE;
-     *   <li>Midnight for TIME;
-     *   <li>The empty string for string types (CHAR, BINARY, VARCHAR, VARBINARY).
-     * </ul>
-     *
-     * @param type Type
-     * @return Simple literal
-     */
-    public RexLiteral makeZeroLiteral(RelDataType type) {
-        return makeLiteral(zeroValue(type), type);
-    }
-
-    private static Comparable zeroValue(RelDataType type) {
-        switch (type.getSqlTypeName()) {
-            case CHAR:
-                return new NlsString(Spaces.of(type.getPrecision()), null, null);
-            case VARCHAR:
-                return new NlsString("", null, null);
-            case BINARY:
-                return new ByteString(new byte[type.getPrecision()]);
-            case VARBINARY:
-                return ByteString.EMPTY;
-            case TINYINT:
-            case SMALLINT:
-            case INTEGER:
-            case BIGINT:
-            case DECIMAL:
-            case FLOAT:
-            case REAL:
-            case DOUBLE:
-                return BigDecimal.ZERO;
-            case BOOLEAN:
-                return false;
-            case TIME:
-            case DATE:
-            case TIMESTAMP:
-                return DateTimeUtils.ZERO_CALENDAR;
-            case TIME_WITH_LOCAL_TIME_ZONE:
-                return new TimeString(0, 0, 0);
-            case TIME_TZ:
-                return new TimeWithTimeZoneString(0, 0, 0, "GMT+00");
-            case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-                return new TimestampString(0, 1, 1, 0, 0, 0);
-            case TIMESTAMP_TZ:
-                return new TimestampWithTimeZoneString(0, 1, 1, 0, 0, 0, "GMT+00");
-            default:
-                throw Util.unexpected(type.getSqlTypeName());
-        }
-    }
-
-    /**
-     * Creates a literal of a given type, padding values of constant-width types to match their
-     * type, not allowing casts.
-     *
-     * @param value Value
-     * @param type Type
-     * @return Simple literal
-     */
-    public RexLiteral makeLiteral(@Nullable Object value, RelDataType type) {
-        return (RexLiteral) makeLiteral(value, type, false, false);
-    }
-
-    /**
-     * Creates a literal of a given type, padding values of constant-width types to match their
-     * type.
-     *
-     * @param value Value
-     * @param type Type
-     * @param allowCast Whether to allow a cast. If false, value is always a {@link RexLiteral} but
-     *     may not be the exact type
-     * @return Simple literal, or cast simple literal
-     */
-    public RexNode makeLiteral(@Nullable Object value, RelDataType type, boolean allowCast) {
-        return makeLiteral(value, type, allowCast, false);
-    }
-
-    /**
-     * Creates a literal of a given type. The value is assumed to be compatible with the type.
-     *
-     * <p>The {@code trim} parameter controls whether to trim values of constant-width types such as
-     * {@code CHAR}. Consider a call to {@code makeLiteral("foo ", CHAR(5)}, and note that the value
-     * is too short for its type. If {@code trim} is true, the value is converted to "foo" and the
-     * type to {@code CHAR(3)}; if {@code trim} is false, the value is right-padded with spaces to
-     * {@code "foo "}, to match the type {@code CHAR(5)}.
-     *
-     * @param value Value
-     * @param type Type
-     * @param allowCast Whether to allow a cast. If false, value is always a {@link RexLiteral} but
-     *     may not be the exact type
-     * @param trim Whether to trim values and type to the shortest equivalent value; for example
-     *     whether to convert CHAR(4) 'foo ' to CHAR(3) 'foo'
-     * @return Simple literal, or cast simple literal
-     */
-    public RexNode makeLiteral(
-            @Nullable Object value, RelDataType type, boolean allowCast, boolean trim) {
-        if (value == null) {
-            return makeCast(type, constantNull);
-        }
-        if (type.isNullable()) {
-            final RelDataType typeNotNull = typeFactory.createTypeWithNullability(type, false);
-            if (allowCast) {
-                RexNode literalNotNull = makeLiteral(value, typeNotNull, allowCast);
-                return makeAbstractCast(type, literalNotNull, false);
-            }
-            type = typeNotNull;
-        }
-        value = clean(value, type);
-        RexLiteral literal;
-        final List<RexNode> operands;
-        final SqlTypeName sqlTypeName = type.getSqlTypeName();
-        switch (sqlTypeName) {
-            case CHAR:
-                final NlsString nlsString = (NlsString) value;
-                if (trim) {
-                    return makeCharLiteral(nlsString.rtrim());
-                } else {
-                    return makeCharLiteral(padRight(nlsString, type.getPrecision()));
-                }
-            case VARCHAR:
-                literal = makeCharLiteral((NlsString) value);
-                if (allowCast) {
-                    return makeCast(type, literal);
-                } else {
-                    return literal;
-                }
-            case BINARY:
-                return makeBinaryLiteral(padRight((ByteString) value, type.getPrecision()));
-            case VARBINARY:
-                literal = makeBinaryLiteral((ByteString) value);
-                if (allowCast) {
-                    return makeCast(type, literal);
-                } else {
-                    return literal;
-                }
-            case TINYINT:
-            case SMALLINT:
-            case INTEGER:
-            case BIGINT:
-            case DECIMAL:
-                if (value instanceof RexLiteral
-                        && ((RexLiteral) value).getTypeName() == SqlTypeName.SARG) {
-                    return (RexNode) value;
-                }
-                return makeExactLiteral((BigDecimal) value, type);
-            case FLOAT:
-            case REAL:
-            case DOUBLE:
-                if (value instanceof Double) {
-                    return makeApproxLiteral((Double) value, type);
-                }
-                return makeApproxLiteral(((BigDecimal) value).doubleValue(), type);
-            case BOOLEAN:
-                return (Boolean) value ? booleanTrue : booleanFalse;
-            case TIME:
-                return makeTimeLiteral((TimeString) value, type.getPrecision());
-            case TIME_WITH_LOCAL_TIME_ZONE:
-                return makeTimeWithLocalTimeZoneLiteral((TimeString) value, type.getPrecision());
-            case TIME_TZ:
-                return makeTimeTzLiteral((TimeWithTimeZoneString) value, type.getPrecision());
-            case DATE:
-                return makeDateLiteral((DateString) value);
-            case TIMESTAMP:
-                return makeTimestampLiteral((TimestampString) value, type.getPrecision());
-            case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-                return makeTimestampWithLocalTimeZoneLiteral(
-                        (TimestampString) value, type.getPrecision());
-            case TIMESTAMP_TZ:
-                return makeTimestampTzLiteral(
-                        (TimestampWithTimeZoneString) value, type.getPrecision());
-            case INTERVAL_YEAR:
-            case INTERVAL_YEAR_MONTH:
-            case INTERVAL_MONTH:
-            case INTERVAL_DAY:
-            case INTERVAL_DAY_HOUR:
-            case INTERVAL_DAY_MINUTE:
-            case INTERVAL_DAY_SECOND:
-            case INTERVAL_HOUR:
-            case INTERVAL_HOUR_MINUTE:
-            case INTERVAL_HOUR_SECOND:
-            case INTERVAL_MINUTE:
-            case INTERVAL_MINUTE_SECOND:
-            case INTERVAL_SECOND:
-                return makeIntervalLiteral(
-                        (BigDecimal) value, castNonNull(type.getIntervalQualifier()));
-            case SYMBOL:
-                return makeFlag((Enum) value);
-            case MAP:
-                final MapSqlType mapType = (MapSqlType) type;
-                @SuppressWarnings("unchecked")
-                final Map<Object, Object> map = (Map) value;
-                operands = new ArrayList<>();
-                for (Map.Entry<Object, Object> entry : map.entrySet()) {
-                    operands.add(makeLiteral(entry.getKey(), mapType.getKeyType(), allowCast));
-                    operands.add(makeLiteral(entry.getValue(), mapType.getValueType(), allowCast));
-                }
-                return makeCall(SqlStdOperatorTable.MAP_VALUE_CONSTRUCTOR, operands);
-            case ARRAY:
-                final ArraySqlType arrayType = (ArraySqlType) type;
-                @SuppressWarnings("unchecked")
-                final List<Object> listValue = (List) value;
-                operands = new ArrayList<>();
-                for (Object entry : listValue) {
-                    operands.add(makeLiteral(entry, arrayType.getComponentType(), allowCast));
-                }
-                return makeCall(SqlStdOperatorTable.ARRAY_VALUE_CONSTRUCTOR, operands);
-            case MULTISET:
-                final MultisetSqlType multisetType = (MultisetSqlType) type;
-                operands = new ArrayList<>();
-                for (Object entry : (List) value) {
-                    final RexNode e =
-                            entry instanceof RexLiteral
-                                    ? (RexNode) entry
-                                    : makeLiteral(
-                                            entry, multisetType.getComponentType(), allowCast);
-                    operands.add(e);
-                }
-                if (allowCast) {
-                    return makeCall(SqlStdOperatorTable.MULTISET_VALUE, operands);
-                } else {
-                    return new RexLiteral((Comparable) FlatLists.of(operands), type, sqlTypeName);
-                }
-            case ROW:
-                operands = new ArrayList<>();
-                //noinspection unchecked
-                for (Pair<RelDataTypeField, Object> pair :
-                        Pair.zip(type.getFieldList(), (List<Object>) value)) {
-                    final RexNode e =
-                            pair.right instanceof RexLiteral
-                                    ? (RexNode) pair.right
-                                    : makeLiteral(pair.right, pair.left.getType(), allowCast);
-                    operands.add(e);
-                }
-                return new RexLiteral((Comparable) FlatLists.of(operands), type, sqlTypeName);
-            case GEOMETRY:
-                return new RexLiteral((Comparable) value, guessType(value), SqlTypeName.GEOMETRY);
-            case ANY:
-                return makeLiteral(value, guessType(value), allowCast);
-            default:
-                throw new IllegalArgumentException(
-                        "Cannot create literal for type '" + sqlTypeName + "'");
-        }
-    }
-
-    /**
-     * Creates a lambda expression.
-     *
-     * @param expr expression of the lambda
-     * @param parameters parameters of the lambda
-     * @return RexNode representing the lambda
-     */
-    public RexNode makeLambdaCall(RexNode expr, List<RexLambdaRef> parameters) {
-        return new RexLambda(parameters, expr);
-    }
-
-    /**
-     * Converts the type of a value to comply with {@link
-     * org.apache.calcite.rex.RexLiteral#valueMatchesType}.
-     *
-     * <p>Returns null if and only if {@code o} is null.
-     */
-    private @PolyNull Object clean(@PolyNull Object o, RelDataType type) {
-        if (o == null) {
-            return o;
-        }
-        if (o instanceof Sarg) {
-            return makeSearchArgumentLiteral((Sarg) o, type);
-        }
-        switch (type.getSqlTypeName()) {
-            case TINYINT:
-            case SMALLINT:
-            case INTEGER:
-            case BIGINT:
-            case DECIMAL:
-            case INTERVAL_YEAR:
-            case INTERVAL_YEAR_MONTH:
-            case INTERVAL_MONTH:
-            case INTERVAL_DAY:
-            case INTERVAL_DAY_HOUR:
-            case INTERVAL_DAY_MINUTE:
-            case INTERVAL_DAY_SECOND:
-            case INTERVAL_HOUR:
-            case INTERVAL_HOUR_MINUTE:
-            case INTERVAL_HOUR_SECOND:
-            case INTERVAL_MINUTE:
-            case INTERVAL_MINUTE_SECOND:
-            case INTERVAL_SECOND:
-                if (o instanceof BigDecimal) {
-                    return o;
-                }
-                assert !(o instanceof Float || o instanceof Double)
-                        : String.format(
-                                Locale.ROOT,
-                                "%s is not compatible with %s, try to use makeExactLiteral",
-                                o.getClass().getCanonicalName(),
-                                type.getSqlTypeName());
-                return new BigDecimal(((Number) o).longValue());
-            case REAL:
-                if (o instanceof BigDecimal) {
-                    return o;
-                }
-                // Float values are stored as Doubles
-                if (o instanceof Float) {
-                    return ((Float) o).doubleValue();
-                }
-                if (o instanceof Double) {
-                    return o;
-                }
-                return new BigDecimal(((Number) o).doubleValue(), MathContext.DECIMAL32)
-                        .stripTrailingZeros();
-            case FLOAT:
-            case DOUBLE:
-                if (o instanceof Double) {
-                    return o;
-                }
-                return ((Number) o).doubleValue();
-            case CHAR:
-            case VARCHAR:
-                if (o instanceof NlsString) {
-                    return o;
-                }
-                final Charset charset = type.getCharset();
-                if (charset == null) {
-                    throw new AssertionError(type + ".getCharset() must not be null");
-                }
-                return new NlsString((String) o, charset.name(), type.getCollation());
-            case TIME:
-                if (o instanceof TimeString) {
-                    return o;
-                } else if (o instanceof Calendar) {
-                    if (!((Calendar) o).getTimeZone().equals(DateTimeUtils.UTC_ZONE)) {
-                        throw new AssertionError();
-                    }
-                    return TimeString.fromCalendarFields((Calendar) o);
-                } else {
-                    return TimeString.fromMillisOfDay((Integer) o);
-                }
-            case TIME_TZ:
-                if (o instanceof TimeWithTimeZoneString) {
-                    return o;
-                } else if (o instanceof Calendar) {
-                    return TimeWithTimeZoneString.fromCalendarFields((Calendar) o);
-                } else {
-                    throw new AssertionError("Value does not contain time zone");
-                }
-            case TIME_WITH_LOCAL_TIME_ZONE:
-                if (o instanceof TimeString) {
-                    return o;
-                } else {
-                    return TimeString.fromMillisOfDay((Integer) o);
-                }
-            case DATE:
-                if (o instanceof DateString) {
-                    return o;
-                } else if (o instanceof Calendar) {
-                    if (!((Calendar) o).getTimeZone().equals(DateTimeUtils.UTC_ZONE)) {
-                        throw new AssertionError();
-                    }
-                    return DateString.fromCalendarFields((Calendar) o);
-                } else {
-                    return DateString.fromDaysSinceEpoch((Integer) o);
-                }
-            case TIMESTAMP:
-                if (o instanceof TimestampString) {
-                    return o;
-                } else if (o instanceof Calendar) {
-                    if (!((Calendar) o).getTimeZone().equals(DateTimeUtils.UTC_ZONE)) {
-                        throw new AssertionError();
-                    }
-                    return TimestampString.fromCalendarFields((Calendar) o);
-                } else {
-                    return TimestampString.fromMillisSinceEpoch((Long) o);
-                }
-            case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-                if (o instanceof TimestampString) {
-                    return o;
-                } else {
-                    return TimestampString.fromMillisSinceEpoch((Long) o);
-                }
-            case TIMESTAMP_TZ:
-                if (o instanceof TimestampWithTimeZoneString) {
-                    return o;
-                } else if (o instanceof Calendar) {
-                    return TimestampWithTimeZoneString.fromCalendarFields((Calendar) o);
-                } else {
-                    throw new AssertionError("Value does not contain time zone");
-                }
-            default:
-                return o;
-        }
-    }
-
-    private RelDataType guessType(@Nullable Object value) {
-        if (value == null) {
-            return typeFactory.createSqlType(SqlTypeName.NULL);
-        }
-        if (value instanceof Float || value instanceof Double) {
-            return typeFactory.createSqlType(SqlTypeName.DOUBLE);
-        }
-        if (value instanceof Number) {
-            return typeFactory.createSqlType(SqlTypeName.BIGINT);
-        }
-        if (value instanceof Boolean) {
-            return typeFactory.createSqlType(SqlTypeName.BOOLEAN);
-        }
-        if (value instanceof String) {
-            return typeFactory.createSqlType(SqlTypeName.CHAR, ((String) value).length());
-        }
-        if (value instanceof ByteString) {
-            return typeFactory.createSqlType(SqlTypeName.BINARY, ((ByteString) value).length());
-        }
-        if (value instanceof Geometry) {
-            return typeFactory.createSqlType(SqlTypeName.GEOMETRY);
-        }
-        throw new AssertionError("unknown type " + value.getClass());
-    }
-
-    /** Returns an {@link NlsString} with spaces to make it at least a given length. */
-    private static NlsString padRight(NlsString s, int length) {
-        if (s.getValue().length() >= length) {
-            return s;
-        }
-        return s.copy(padRight(s.getValue(), length));
-    }
-
-    /** Returns a string padded with spaces to make it at least a given length. */
-    private static String padRight(String s, int length) {
-        if (s.length() >= length) {
-            return s;
-        }
-        return new StringBuilder().append(s).append(Spaces.MAX, s.length(), length).toString();
-    }
-
-    /** Returns a byte-string padded with zero bytes to make it at least a given length. */
-    private static ByteString padRight(ByteString s, int length) {
-        if (s.length() >= length) {
-            return s;
-        }
-        return new ByteString(Arrays.copyOf(s.getBytes(), length));
-    }
-}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexChecker.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexChecker.java
deleted file mode 100644
index 572f1192f6587..0000000000000
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexChecker.java
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.rex;
-
-import org.apache.calcite.plan.RelOptUtil;
-import org.apache.calcite.rel.RelNode;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeField;
-import org.apache.calcite.util.Litmus;
-
-import java.util.List;
-
-import static java.util.Objects.requireNonNull;
-
-/**
- * Visitor which checks the validity of a {@link RexNode} expression.
- *
- * <p>FLINK modifications (backport of CALCITE-6764): Lines 121 ~ 133, 164 ~ 177
- *
- * <p>There are two modes of operation:
- *
- * <ul>
- *   <li>{@link Litmus#THROW} causes the checker to throw an {@link AssertionError} as soon as an
- *       invalid node is detected. Note: This mode requires that assertions are enabled.
- *       <blockquote>
- *       <pre>
- * // Example usage of Litmus.THROW
- * RexNode node;
- * RelDataType rowType;
- * RexChecker checker = new RexChecker(rowType, Litmus.THROW);
- * node.accept(checker); // Will throw an AssertionError if node is invalid
- * </pre>
- *       </blockquote>
- *   <li>{@link Litmus#IGNORE} tests validity without throwing an error.
- *       <blockquote>
- *       <pre>
- * // Example usage of Litmus.IGNORE
- * RexNode node;
- * RelDataType rowType;
- * RexChecker checker = new RexChecker(rowType, Litmus.IGNORE);
- * node.accept(checker);
- * if (!checker.isValid()) {
- *     // Handle invalid node
- * }
- * </pre>
- *       </blockquote>
- * </ul>
- *
- * @see RexNode
- */
-public class RexChecker extends RexVisitorImpl<Boolean> {
-    // ~ Instance fields --------------------------------------------------------
-
-    protected final RelNode.Context context;
-    protected final Litmus litmus;
-    protected final List<RelDataType> inputTypeList;
-    protected int failCount;
-
-    // ~ Constructors -----------------------------------------------------------
-
-    /**
-     * Creates a RexChecker with a given input row type.
-     *
-     * <p>If <code>fail</code> is true, the checker will throw an {@link AssertionError} if an
-     * invalid node is found and assertions are enabled.
-     *
-     * <p>Otherwise, each method returns whether its part of the tree is valid.
-     *
-     * @param inputRowType Input row type
-     * @param context Context of the enclosing {@link RelNode}, or null
-     * @param litmus What to do if an invalid node is detected
-     */
-    public RexChecker(final RelDataType inputRowType, RelNode.Context context, Litmus litmus) {
-        this(RelOptUtil.getFieldTypeList(inputRowType), context, litmus);
-    }
-
-    /**
-     * Creates a RexChecker with a given set of input fields.
-     *
-     * <p>If <code>fail</code> is true, the checker will throw an {@link AssertionError} if an
-     * invalid node is found and assertions are enabled.
-     *
-     * <p>Otherwise, each method returns whether its part of the tree is valid.
-     *
-     * @param inputTypeList Input row type
-     * @param context Context of the enclosing {@link RelNode}, or null
-     * @param litmus What to do if an error is detected
-     */
-    public RexChecker(List<RelDataType> inputTypeList, RelNode.Context context, Litmus litmus) {
-        super(true);
-        this.inputTypeList = inputTypeList;
-        this.context = context;
-        this.litmus = litmus;
-    }
-
-    // ~ Methods ----------------------------------------------------------------
-
-    /**
-     * Returns the number of failures encountered.
-     *
-     * @return Number of failures
-     */
-    public int getFailureCount() {
-        return failCount;
-    }
-
-    @Override
-    public Boolean visitInputRef(RexInputRef ref) {
-        final int index = ref.getIndex();
-        if ((index < 0) || (index >= inputTypeList.size())) {
-            ++failCount;
-            return litmus.fail(
-                    "RexInputRef index {} out of range 0..{}", index, inputTypeList.size() - 1);
-        }
-        // Type of field and type of result can differ in nullability.  See [CALCITE-6764]
-        if (!ref.getType().isStruct()
-                && !RelOptUtil.eqUpToNullability(
-                        ref.getType().isNullable(),
-                        "ref",
-                        ref.getType(),
-                        "input",
-                        inputTypeList.get(index),
-                        litmus)) {
-            ++failCount;
-            return litmus.fail(null);
-        }
-        return litmus.succeed();
-    }
-
-    @Override
-    public Boolean visitLocalRef(RexLocalRef ref) {
-        ++failCount;
-        return litmus.fail("RexLocalRef illegal outside program");
-    }
-
-    @Override
-    public Boolean visitCall(RexCall call) {
-        for (RexNode operand : call.getOperands()) {
-            Boolean valid = operand.accept(this);
-            if (valid != null && !valid) {
-                return litmus.fail(null);
-            }
-        }
-        return litmus.succeed();
-    }
-
-    @Override
-    public Boolean visitFieldAccess(RexFieldAccess fieldAccess) {
-        super.visitFieldAccess(fieldAccess);
-        final RelDataType refType = fieldAccess.getReferenceExpr().getType();
-        assert refType.isStruct();
-        final RelDataTypeField field = fieldAccess.getField();
-        final int index = field.getIndex();
-        if ((index < 0) || (index >= refType.getFieldList().size())) {
-            ++failCount;
-            return litmus.fail(null);
-        }
-        // Type of field may not match type of field access - they may differ in nullability
-        final RelDataTypeField typeField = refType.getFieldList().get(index);
-        if (!RelOptUtil.eqUpToNullability(
-                refType.isNullable(),
-                "type1",
-                typeField.getType(),
-                "type2",
-                fieldAccess.getType(),
-                litmus)) {
-            ++failCount;
-            return litmus.fail(null);
-        }
-        return litmus.succeed();
-    }
-
-    @Override
-    public Boolean visitCorrelVariable(RexCorrelVariable v) {
-        if (context != null && !context.correlationIds().contains(v.id)) {
-            ++failCount;
-            return litmus.fail(
-                    "correlation id {} not found in correlation list {}",
-                    v,
-                    context.correlationIds());
-        }
-        return litmus.succeed();
-    }
-
-    /** Returns whether an expression is valid. */
-    public final boolean isValid(RexNode expr) {
-        return requireNonNull(expr.accept(this), () -> "expr.accept(RexChecker) for expr=" + expr);
-    }
-}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexFieldAccess.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexFieldAccess.java
deleted file mode 100644
index 955cc334db62b..0000000000000
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexFieldAccess.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.rex;
-
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeField;
-import org.apache.calcite.sql.SqlKind;
-import org.checkerframework.checker.nullness.qual.Nullable;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-/**
- * Access to a field of a row-expression.
- *
- * <p>FLINK modifications (backport of CALCITE-6764): Lines 59, 63 ~ 65, 67 ~ 73, 95
- *
- * <p>You might expect to use a <code>RexFieldAccess</code> to access columns of relational tables,
- * for example, the expression <code>emp.empno</code> in the query
- *
- * <blockquote>
- *
- * <pre>SELECT emp.empno FROM emp</pre>
- *
- * </blockquote>
- *
- * <p>but there is a specialized expression {@link RexInputRef} for this purpose. So in practice,
- * <code>RexFieldAccess</code> is usually used to access fields of correlating variables, for
- * example the expression <code>emp.deptno</code> in
- *
- * <blockquote>
- *
- * <pre>SELECT ename
- * FROM dept
- * WHERE EXISTS (
- *     SELECT NULL
- *     FROM emp
- *     WHERE emp.deptno = dept.deptno
- *     AND gender = 'F')</pre>
- *
- * </blockquote>
- */
-public class RexFieldAccess extends RexNode {
-    // ~ Instance fields --------------------------------------------------------
-
-    private final RexNode expr;
-    private final RelDataTypeField field;
-    // Not always the same as the field.getType().
-    private final RelDataType type;
-
-    // ~ Constructors -----------------------------------------------------------
-
-    RexFieldAccess(RexNode expr, RelDataTypeField field) {
-        this(expr, field, field.getType());
-    }
-
-    RexFieldAccess(RexNode expr, RelDataTypeField field, RelDataType type) {
-        checkValid(expr, field);
-        this.expr = expr;
-        this.field = field;
-        this.digest = expr + "." + field.getName();
-        this.type = type;
-    }
-
-    // ~ Methods ----------------------------------------------------------------
-
-    private static void checkValid(RexNode expr, RelDataTypeField field) {
-        RelDataType exprType = expr.getType();
-        int fieldIdx = field.getIndex();
-        checkArgument(
-                fieldIdx >= 0
-                        && fieldIdx < exprType.getFieldList().size()
-                        && exprType.getFieldList().get(fieldIdx).equals(field),
-                "Field %s does not exist for expression %s",
-                field,
-                expr);
-    }
-
-    public RelDataTypeField getField() {
-        return field;
-    }
-
-    @Override
-    public RelDataType getType() {
-        return type;
-    }
-
-    @Override
-    public SqlKind getKind() {
-        return SqlKind.FIELD_ACCESS;
-    }
-
-    @Override
-    public <R> R accept(RexVisitor<R> visitor) {
-        return visitor.visitFieldAccess(this);
-    }
-
-    @Override
-    public <R, P> R accept(RexBiVisitor<R, P> visitor, P arg) {
-        return visitor.visitFieldAccess(this, arg);
-    }
-
-    /** Returns the expression whose field is being accessed. */
-    public RexNode getReferenceExpr() {
-        return expr;
-    }
-
-    @Override
-    public boolean equals(@Nullable Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (o == null || getClass() != o.getClass()) {
-            return false;
-        }
-
-        RexFieldAccess that = (RexFieldAccess) o;
-
-        return field.equals(that.field) && expr.equals(that.expr);
-    }
-
-    @Override
-    public int hashCode() {
-        int result = expr.hashCode();
-        result = 31 * result + field.hashCode();
-        return result;
-    }
-}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexProgram.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexProgram.java
deleted file mode 100644
index 04dea5bbca1b3..0000000000000
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexProgram.java
+++ /dev/null
@@ -1,984 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.rex;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Ordering;
-import org.apache.calcite.linq4j.Ord;
-import org.apache.calcite.plan.RelOptPredicateList;
-import org.apache.calcite.plan.RelOptUtil;
-import org.apache.calcite.rel.RelCollation;
-import org.apache.calcite.rel.RelCollations;
-import org.apache.calcite.rel.RelFieldCollation;
-import org.apache.calcite.rel.RelInput;
-import org.apache.calcite.rel.RelNode;
-import org.apache.calcite.rel.RelWriter;
-import org.apache.calcite.rel.externalize.RelJsonWriter;
-import org.apache.calcite.rel.externalize.RelWriterImpl;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeField;
-import org.apache.calcite.sql.SqlExplainLevel;
-import org.apache.calcite.sql.fun.SqlStdOperatorTable;
-import org.apache.calcite.sql.type.SqlTypeUtil;
-import org.apache.calcite.util.Litmus;
-import org.apache.calcite.util.Pair;
-import org.apache.calcite.util.Permutation;
-import org.apache.calcite.util.mapping.MappingType;
-import org.apache.calcite.util.mapping.Mappings;
-import org.checkerframework.checker.nullness.qual.Nullable;
-
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.util.AbstractList;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import static java.util.Objects.requireNonNull;
-import static org.apache.calcite.linq4j.Nullness.castNonNull;
-
-/**
- * A collection of expressions which read inputs, compute output expressions, and optionally use a
- * condition to filter rows.
- *
- * <p>Programs are immutable. It may help to use a {@link RexProgramBuilder}, which has the same
- * relationship to {@link RexProgram} as {@link StringBuilder} has to {@link String}.
- *
- * <p>A program can contain aggregate functions. If it does, the arguments to each aggregate
- * function must be an {@link RexInputRef}.
- *
- * <p>FLINK modifications (backport of CALCITE-6764): Lines 999 ~ 1002
- *
- * @see RexProgramBuilder
- */
-public class RexProgram {
-    // ~ Instance fields --------------------------------------------------------
-
-    /**
-     * First stage of expression evaluation. The expressions in this array can refer to inputs
-     * (using input ordinal #0) or previous expressions in the array (using input ordinal #1).
-     */
-    private final List<RexNode> exprs;
-
-    /** With {@link #condition}, the second stage of expression evaluation. */
-    private final List<RexLocalRef> projects;
-
-    /** The optional condition. If null, the calculator does not filter rows. */
-    private final @Nullable RexLocalRef condition;
-
-    private final RelDataType inputRowType;
-
-    private final RelDataType outputRowType;
-
-    /** Reference counts for each expression, computed on demand. */
-    private int[] refCounts;
-
-    // ~ Constructors -----------------------------------------------------------
-
-    /**
-     * Creates a program.
-     *
-     * <p>The expressions must be valid: they must not contain common expressions, forward
-     * references, or non-trivial aggregates.
-     *
-     * @param inputRowType Input row type
-     * @param exprs Common expressions
-     * @param projects Projection expressions
-     * @param condition Condition expression. If null, calculator does not filter rows
-     * @param outputRowType Description of the row produced by the program
-     */
-    public RexProgram(
-            RelDataType inputRowType,
-            List<? extends RexNode> exprs,
-            List<RexLocalRef> projects,
-            @Nullable RexLocalRef condition,
-            RelDataType outputRowType) {
-        this.inputRowType = inputRowType;
-        this.exprs = ImmutableList.copyOf(exprs);
-        this.projects = ImmutableList.copyOf(projects);
-        this.condition = condition;
-        this.outputRowType = outputRowType;
-        assert isValid(Litmus.THROW, null);
-    }
-
-    // ~ Methods ----------------------------------------------------------------
-
-    // REVIEW jvs 16-Oct-2006:  The description below is confusing.  I
-    // think it means "none of the entries are null, there may be none,
-    // and there is no further reduction into smaller common sub-expressions
-    // possible"?
-
-    /**
-     * Returns the common sub-expressions of this program.
-     *
-     * <p>The list is never null but may be empty; each the expression in the list is not null; and
-     * no further reduction into smaller common sub-expressions is possible.
-     */
-    public List<RexNode> getExprList() {
-        return exprs;
-    }
-
-    /**
-     * Returns an array of references to the expressions which this program is to project. Never
-     * null, may be empty.
-     */
-    public List<RexLocalRef> getProjectList() {
-        return projects;
-    }
-
-    /** Returns a list of project expressions and their field names. */
-    public List<Pair<RexLocalRef, String>> getNamedProjects() {
-        return new AbstractList<Pair<RexLocalRef, String>>() {
-            @Override
-            public int size() {
-                return projects.size();
-            }
-
-            @Override
-            public Pair<RexLocalRef, String> get(int index) {
-                return Pair.of(
-                        projects.get(index), outputRowType.getFieldList().get(index).getName());
-            }
-        };
-    }
-
-    /**
-     * Returns the field reference of this program's filter condition, or null if there is no
-     * condition.
-     */
-    public @Nullable RexLocalRef getCondition() {
-        return condition;
-    }
-
-    /**
-     * Creates a program which calculates projections and filters rows based upon a condition. Does
-     * not attempt to eliminate common sub-expressions.
-     *
-     * @param projectExprs Project expressions
-     * @param conditionExpr Condition on which to filter rows, or null if rows are not to be
-     *     filtered
-     * @param outputRowType Output row type
-     * @param rexBuilder Builder of rex expressions
-     * @return A program
-     */
-    public static RexProgram create(
-            RelDataType inputRowType,
-            List<? extends RexNode> projectExprs,
-            @Nullable RexNode conditionExpr,
-            RelDataType outputRowType,
-            RexBuilder rexBuilder) {
-        return create(
-                inputRowType,
-                projectExprs,
-                conditionExpr,
-                outputRowType.getFieldNames(),
-                rexBuilder);
-    }
-
-    /**
-     * Creates a program which calculates projections and filters rows based upon a condition. Does
-     * not attempt to eliminate common sub-expressions.
-     *
-     * @param projectExprs Project expressions
-     * @param conditionExpr Condition on which to filter rows, or null if rows are not to be
-     *     filtered
-     * @param fieldNames Names of projected fields
-     * @param rexBuilder Builder of rex expressions
-     * @return A program
-     */
-    public static RexProgram create(
-            RelDataType inputRowType,
-            List<? extends RexNode> projectExprs,
-            @Nullable RexNode conditionExpr,
-            @Nullable List<? extends @Nullable String> fieldNames,
-            RexBuilder rexBuilder) {
-        if (fieldNames == null) {
-            fieldNames = Collections.nCopies(projectExprs.size(), null);
-        } else {
-            assert fieldNames.size() == projectExprs.size()
-                    : "fieldNames=" + fieldNames + ", exprs=" + projectExprs;
-        }
-        final RexProgramBuilder programBuilder = new RexProgramBuilder(inputRowType, rexBuilder);
-        for (int i = 0; i < projectExprs.size(); i++) {
-            programBuilder.addProject(projectExprs.get(i), fieldNames.get(i));
-        }
-        if (conditionExpr != null) {
-            programBuilder.addCondition(conditionExpr);
-        }
-        return programBuilder.getProgram();
-    }
-
-    /**
-     * Create a program from serialized output. In this case, the input is mainly from the output
-     * json string of {@link RelJsonWriter}
-     */
-    public static RexProgram create(RelInput input) {
-        final List<RexNode> exprs = requireNonNull(input.getExpressionList("exprs"), "exprs");
-        final List<RexNode> projectRexNodes =
-                requireNonNull(input.getExpressionList("projects"), "projects");
-        final List<RexLocalRef> projects = new ArrayList<>(projectRexNodes.size());
-        for (RexNode rexNode : projectRexNodes) {
-            projects.add((RexLocalRef) rexNode);
-        }
-        final RelDataType inputType = input.getRowType("inputRowType");
-        final RelDataType outputType = input.getRowType("outputRowType");
-        final RexLocalRef condition = (RexLocalRef) input.getExpression("condition");
-        return new RexProgram(inputType, exprs, projects, condition, outputType);
-    }
-
-    // description of this calc, chiefly intended for debugging
-    @Override
-    public String toString() {
-        // Intended to produce similar output to explainCalc,
-        // but without requiring a RelNode or RelOptPlanWriter.
-        final RelWriterImpl pw = new RelWriterImpl(new PrintWriter(new StringWriter()));
-        collectExplainTerms("", pw);
-        return pw.simple();
-    }
-
-    /**
-     * Writes an explanation of the expressions in this program to a plan writer.
-     *
-     * @param pw Plan writer
-     */
-    public RelWriter explainCalc(RelWriter pw) {
-        if (pw instanceof RelJsonWriter) {
-            return pw.item("exprs", exprs)
-                    .item("projects", projects)
-                    .item("condition", condition)
-                    .item("inputRowType", inputRowType)
-                    .item("outputRowType", outputRowType);
-        } else {
-            return collectExplainTerms("", pw, pw.getDetailLevel());
-        }
-    }
-
-    public RelWriter collectExplainTerms(String prefix, RelWriter pw) {
-        return collectExplainTerms(prefix, pw, SqlExplainLevel.EXPPLAN_ATTRIBUTES);
-    }
-
-    /**
-     * Collects the expressions in this program into a list of terms and values.
-     *
-     * @param prefix Prefix for term names, usually the empty string, but useful if a relational
-     *     expression contains more than one program
-     * @param pw Plan writer
-     */
-    public RelWriter collectExplainTerms(String prefix, RelWriter pw, SqlExplainLevel level) {
-        final List<RelDataTypeField> inFields = inputRowType.getFieldList();
-        final List<RelDataTypeField> outFields = outputRowType.getFieldList();
-        assert outFields.size() == projects.size()
-                : "outFields.length=" + outFields.size() + ", projects.length=" + projects.size();
-        pw.item(
-                prefix + "expr#0" + ((inFields.size() > 1) ? (".." + (inFields.size() - 1)) : ""),
-                "{inputs}");
-        for (int i = inFields.size(); i < exprs.size(); i++) {
-            pw.item(prefix + "expr#" + i, exprs.get(i));
-        }
-
-        // If a lot of the fields are simply projections of the underlying
-        // expression, try to be a bit less verbose.
-        int trivialCount = countTrivial(projects);
-
-        switch (trivialCount) {
-            case 0:
-                break;
-            case 1:
-                trivialCount = 0;
-                break;
-            default:
-                pw.item(prefix + "proj#0.." + (trivialCount - 1), "{exprs}");
-                break;
-        }
-
-        final boolean withFieldNames = level != SqlExplainLevel.DIGEST_ATTRIBUTES;
-        // Print the non-trivial fields with their names as they appear in the
-        // output row type.
-        for (int i = trivialCount; i < projects.size(); i++) {
-            final String fieldName =
-                    withFieldNames ? prefix + outFields.get(i).getName() : prefix + i;
-            pw.item(fieldName, projects.get(i));
-        }
-        if (condition != null) {
-            pw.item(prefix + "$condition", condition);
-        }
-        return pw;
-    }
-
-    /**
-     * Returns the number of expressions at the front of an array which are simply projections of
-     * the same field.
-     *
-     * @param refs References
-     */
-    private static int countTrivial(List<RexLocalRef> refs) {
-        for (int i = 0; i < refs.size(); i++) {
-            RexLocalRef ref = refs.get(i);
-            if (ref.getIndex() != i) {
-                return i;
-            }
-        }
-        return refs.size();
-    }
-
-    /** Returns the number of expressions in this program. */
-    public int getExprCount() {
-        return exprs.size() + projects.size() + ((condition == null) ? 0 : 1);
-    }
-
-    /** Creates the identity program. */
-    public static RexProgram createIdentity(RelDataType rowType) {
-        return createIdentity(rowType, rowType);
-    }
-
-    /**
-     * Creates a program that projects its input fields but with possibly different names for the
-     * output fields.
-     */
-    public static RexProgram createIdentity(RelDataType rowType, RelDataType outputRowType) {
-        if (rowType != outputRowType
-                && !Pair.right(rowType.getFieldList())
-                        .equals(Pair.right(outputRowType.getFieldList()))) {
-            throw new IllegalArgumentException(
-                    "field type mismatch: " + rowType + " vs. " + outputRowType);
-        }
-        final List<RelDataTypeField> fields = rowType.getFieldList();
-        final List<RexLocalRef> projectRefs = new ArrayList<>();
-        final List<RexInputRef> refs = new ArrayList<>();
-        for (int i = 0; i < fields.size(); i++) {
-            final RexInputRef ref = RexInputRef.of(i, fields);
-            refs.add(ref);
-            projectRefs.add(new RexLocalRef(i, ref.getType()));
-        }
-        return new RexProgram(rowType, refs, projectRefs, null, outputRowType);
-    }
-
-    /**
-     * Returns the type of the input row to the program.
-     *
-     * @return input row type
-     */
-    public RelDataType getInputRowType() {
-        return inputRowType;
-    }
-
-    /**
-     * Returns whether this program contains windowed aggregate functions.
-     *
-     * @return whether this program contains windowed aggregate functions
-     */
-    public boolean containsAggs() {
-        return RexOver.containsOver(this);
-    }
-
-    /**
-     * Returns the type of the output row from this program.
-     *
-     * @return output row type
-     */
-    public RelDataType getOutputRowType() {
-        return outputRowType;
-    }
-
-    /**
-     * Checks that this program is valid.
-     *
-     * <p>If <code>fail</code> is true, executes <code>assert false</code>, so will throw an {@link
-     * AssertionError} if assertions are enabled. If <code>
-     * fail</code> is false, merely returns whether the program is valid.
-     *
-     * @param litmus What to do if an error is detected
-     * @param context Context of enclosing {@link RelNode}, for validity checking, or null if not
-     *     known
-     * @return Whether the program is valid
-     */
-    public boolean isValid(Litmus litmus, RelNode.Context context) {
-        if (inputRowType == null) {
-            return litmus.fail(null);
-        }
-        if (exprs == null) {
-            return litmus.fail(null);
-        }
-        if (projects == null) {
-            return litmus.fail(null);
-        }
-        if (outputRowType == null) {
-            return litmus.fail(null);
-        }
-
-        // If the input row type is a struct (contains fields) then the leading
-        // expressions must be references to those fields. But we don't require
-        // this if the input row type is, say, a java class.
-        if (inputRowType.isStruct()) {
-            if (!RexUtil.containIdentity(exprs, inputRowType, litmus)) {
-                return litmus.fail(null);
-            }
-
-            // None of the other fields should be inputRefs.
-            for (int i = inputRowType.getFieldCount(); i < exprs.size(); i++) {
-                RexNode expr = exprs.get(i);
-                if (expr instanceof RexInputRef) {
-                    return litmus.fail(null);
-                }
-            }
-        }
-        // todo: enable
-        // CHECKSTYLE: IGNORE 1
-        if (false && RexUtil.containNoCommonExprs(exprs, litmus)) {
-            return litmus.fail(null);
-        }
-        if (!RexUtil.containNoForwardRefs(exprs, inputRowType, litmus)) {
-            return litmus.fail(null);
-        }
-        if (!RexUtil.containNoNonTrivialAggs(exprs, litmus)) {
-            return litmus.fail(null);
-        }
-        final Checker checker = new Checker(inputRowType, RexUtil.types(exprs), null, litmus);
-        if (condition != null) {
-            if (!SqlTypeUtil.inBooleanFamily(condition.getType())) {
-                return litmus.fail("condition must be boolean");
-            }
-            condition.accept(checker);
-            if (checker.failCount > 0) {
-                return litmus.fail(null);
-            }
-        }
-        for (RexLocalRef project : projects) {
-            project.accept(checker);
-            if (checker.failCount > 0) {
-                return litmus.fail(null);
-            }
-        }
-        for (RexNode expr : exprs) {
-            expr.accept(checker);
-            if (checker.failCount > 0) {
-                return litmus.fail(null);
-            }
-        }
-        return litmus.succeed();
-    }
-
-    /**
-     * Returns whether an expression always evaluates to null.
-     *
-     * <p>Like {@link RexUtil#isNull(RexNode)}, null literals are null, and casts of null literals
-     * are null. But this method also regards references to null expressions as null.
-     *
-     * @param expr Expression
-     * @return Whether expression always evaluates to null
-     */
-    public boolean isNull(RexNode expr) {
-        switch (expr.getKind()) {
-            case LITERAL:
-                return ((RexLiteral) expr).getValue2() == null;
-            case LOCAL_REF:
-                RexLocalRef inputRef = (RexLocalRef) expr;
-                return isNull(exprs.get(inputRef.index));
-            case CAST:
-                return isNull(((RexCall) expr).operands.get(0));
-            default:
-                return false;
-        }
-    }
-
-    /**
-     * Fully expands a RexLocalRef back into a pure RexNode tree containing no RexLocalRefs
-     * (reversing the effect of common subexpression elimination). For example, <code>
-     * program.expandLocalRef(program.getCondition())</code> will return the expansion of a
-     * program's condition.
-     *
-     * @param ref a RexLocalRef from this program
-     * @return expanded form
-     */
-    public RexNode expandLocalRef(RexLocalRef ref) {
-        return ref.accept(new ExpansionShuttle(exprs));
-    }
-
-    /** Expands a list of expressions that may contain {@link RexLocalRef}s. */
-    public List<RexNode> expandList(List<? extends RexNode> nodes) {
-        return new ExpansionShuttle(exprs).visitList(nodes);
-    }
-
-    /**
-     * Splits this program into a list of project expressions and a list of filter expressions.
-     *
-     * <p>Neither list is null. The filters are evaluated first.
-     */
-    public Pair<ImmutableList<RexNode>, ImmutableList<RexNode>> split() {
-        final List<RexNode> filters = new ArrayList<>();
-        if (condition != null) {
-            RelOptUtil.decomposeConjunction(expandLocalRef(condition), filters);
-        }
-        final ImmutableList.Builder<RexNode> projects = ImmutableList.builder();
-        for (RexLocalRef project : this.projects) {
-            projects.add(expandLocalRef(project));
-        }
-        return Pair.of(projects.build(), ImmutableList.copyOf(filters));
-    }
-
-    /**
-     * Given a list of collations which hold for the input to this program, returns a list of
-     * collations which hold for its output. The result is mutable and sorted.
-     */
-    public List<RelCollation> getCollations(List<RelCollation> inputCollations) {
-        final List<RelCollation> outputCollations = new ArrayList<>();
-        deduceCollations(outputCollations, inputRowType.getFieldCount(), projects, inputCollations);
-        return outputCollations;
-    }
-
-    /**
-     * Given a list of expressions and a description of which are ordered, populates a list of
-     * collations, sorted in natural order.
-     */
-    public static void deduceCollations(
-            List<RelCollation> outputCollations,
-            final int sourceCount,
-            List<RexLocalRef> refs,
-            List<RelCollation> inputCollations) {
-        int[] targets = new int[sourceCount];
-        Arrays.fill(targets, -1);
-        for (int i = 0; i < refs.size(); i++) {
-            final RexLocalRef ref = refs.get(i);
-            final int source = ref.getIndex();
-            if ((source < sourceCount) && (targets[source] == -1)) {
-                targets[source] = i;
-            }
-        }
-        loop:
-        for (RelCollation collation : inputCollations) {
-            final List<RelFieldCollation> fieldCollations = new ArrayList<>(0);
-            for (RelFieldCollation fieldCollation : collation.getFieldCollations()) {
-                final int source = fieldCollation.getFieldIndex();
-                final int target = targets[source];
-                if (target < 0) {
-                    continue loop;
-                }
-                fieldCollations.add(fieldCollation.withFieldIndex(target));
-            }
-
-            // Success -- all of the source fields of this key are mapped
-            // to the output.
-            outputCollations.add(RelCollations.of(fieldCollations));
-        }
-        outputCollations.sort(Ordering.natural());
-    }
-
-    /**
-     * Returns whether the fields on the leading edge of the project list are the input fields.
-     *
-     * @param fail Whether to throw an assert failure if does not project identity
-     */
-    public boolean projectsIdentity(final boolean fail) {
-        final int fieldCount = inputRowType.getFieldCount();
-        if (projects.size() < fieldCount) {
-            assert !fail
-                    : "program '"
-                            + toString()
-                            + "' does not project identity for input row type '"
-                            + inputRowType
-                            + "'";
-            return false;
-        }
-        for (int i = 0; i < fieldCount; i++) {
-            RexLocalRef project = projects.get(i);
-            if (project.index != i) {
-                assert !fail
-                        : "program "
-                                + toString()
-                                + "' does not project identity for input row type '"
-                                + inputRowType
-                                + "', field #"
-                                + i;
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Returns whether this program projects precisely its input fields. It may or may not apply a
-     * condition.
-     */
-    public boolean projectsOnlyIdentity() {
-        if (projects.size() != inputRowType.getFieldCount()) {
-            return false;
-        }
-        for (int i = 0; i < projects.size(); i++) {
-            RexLocalRef project = projects.get(i);
-            if (project.index != i) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Returns whether this program returns its input exactly.
-     *
-     * <p>This is a stronger condition than {@link #projectsIdentity(boolean)}.
-     */
-    public boolean isTrivial() {
-        return getCondition() == null && projectsOnlyIdentity();
-    }
-
-    /**
-     * Gets reference counts for each expression in the program, where the references are detected
-     * from later expressions in the same program, as well as the project list and condition.
-     * Expressions with references counts greater than 1 are true common sub-expressions.
-     *
-     * @return array of reference counts; the ith element in the returned array is the number of
-     *     references to getExprList()[i]
-     */
-    public int[] getReferenceCounts() {
-        if (refCounts != null) {
-            return refCounts;
-        }
-        refCounts = new int[exprs.size()];
-        ReferenceCounter refCounter = new ReferenceCounter(refCounts);
-        RexUtil.apply(refCounter, exprs, null);
-        if (condition != null) {
-            refCounter.visitLocalRef(condition);
-        }
-        for (RexLocalRef project : projects) {
-            refCounter.visitLocalRef(project);
-        }
-        return refCounts;
-    }
-
-    /** Returns whether an expression is constant. */
-    public boolean isConstant(RexNode ref) {
-        return ref.accept(new ConstantFinder());
-    }
-
-    public @Nullable RexNode gatherExpr(RexNode expr) {
-        return expr.accept(new Marshaller());
-    }
-
-    /**
-     * Returns the input field that an output field is populated from, or -1 if it is populated from
-     * an expression.
-     */
-    public int getSourceField(int outputOrdinal) {
-        assert (outputOrdinal >= 0) && (outputOrdinal < this.projects.size());
-        RexLocalRef project = projects.get(outputOrdinal);
-        int index = project.index;
-        while (true) {
-            RexNode expr = exprs.get(index);
-            if (expr instanceof RexCall
-                    && ((RexCall) expr).getOperator() == SqlStdOperatorTable.IN_FENNEL) {
-                // drill through identity function
-                expr = ((RexCall) expr).getOperands().get(0);
-            }
-            if (expr instanceof RexLocalRef) {
-                index = ((RexLocalRef) expr).index;
-            } else if (expr instanceof RexInputRef) {
-                return ((RexInputRef) expr).index;
-            } else {
-                return -1;
-            }
-        }
-    }
-
-    /** Returns whether this program is a permutation of its inputs. */
-    public boolean isPermutation() {
-        if (projects.size() != inputRowType.getFieldList().size()) {
-            return false;
-        }
-        for (int i = 0; i < projects.size(); ++i) {
-            if (getSourceField(i) < 0) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /** Returns a permutation, if this program is a permutation, otherwise null. */
-    public @Nullable Permutation getPermutation() {
-        Permutation permutation = new Permutation(projects.size());
-        if (projects.size() != inputRowType.getFieldList().size()) {
-            return null;
-        }
-        for (int i = 0; i < projects.size(); ++i) {
-            int sourceField = getSourceField(i);
-            if (sourceField < 0) {
-                return null;
-            }
-            permutation.set(i, sourceField);
-        }
-        return permutation;
-    }
-
-    /**
-     * Returns the set of correlation variables used (read) by this program.
-     *
-     * @return set of correlation variable names
-     */
-    public Set<String> getCorrelVariableNames() {
-        final Set<String> paramIdSet = new HashSet<>();
-        RexUtil.apply(
-                new RexVisitorImpl<Void>(true) {
-                    @Override
-                    public Void visitCorrelVariable(RexCorrelVariable correlVariable) {
-                        paramIdSet.add(correlVariable.getName());
-                        return null;
-                    }
-                },
-                exprs,
-                null);
-        return paramIdSet;
-    }
-
-    /**
-     * Returns whether this program is in canonical form.
-     *
-     * @param litmus What to do if an error is detected (program is not in canonical form)
-     * @param rexBuilder Rex builder
-     * @return whether in canonical form
-     */
-    public boolean isNormalized(Litmus litmus, RexBuilder rexBuilder) {
-        final RexProgram normalizedProgram = normalize(rexBuilder, null);
-        String normalized = normalizedProgram.toString();
-        String string = toString();
-        if (!normalized.equals(string)) {
-            final String message =
-                    "Program is not normalized:\n" + "program:    {}\n" + "normalized: {}\n";
-            return litmus.fail(message, string, normalized);
-        }
-        return litmus.succeed();
-    }
-
-    /**
-     * Creates a simplified/normalized copy of this program.
-     *
-     * @param rexBuilder Rex builder
-     * @param simplify Simplifier to simplify (in addition to normalizing), or null to not simplify
-     * @return Normalized program
-     */
-    public RexProgram normalize(RexBuilder rexBuilder, @Nullable RexSimplify simplify) {
-        // Normalize program by creating program builder from the program, then
-        // converting to a program. getProgram does not need to normalize
-        // because the builder was normalized on creation.
-        assert isValid(Litmus.THROW, null);
-        final RexProgramBuilder builder =
-                RexProgramBuilder.create(
-                        rexBuilder,
-                        inputRowType,
-                        exprs,
-                        projects,
-                        condition,
-                        outputRowType,
-                        true,
-                        simplify);
-        return builder.getProgram(false);
-    }
-
-    @Deprecated // to be removed before 2.0
-    public RexProgram normalize(RexBuilder rexBuilder, boolean simplify) {
-        final RelOptPredicateList predicates = RelOptPredicateList.EMPTY;
-        return normalize(
-                rexBuilder,
-                simplify ? new RexSimplify(rexBuilder, predicates, RexUtil.EXECUTOR) : null);
-    }
-
-    /**
-     * Returns a partial mapping of a set of project expressions.
-     *
-     * <p>The mapping is an inverse function. Every target has a source field, but a source might
-     * have 0, 1 or more targets. Project expressions that do not consist of a mapping are ignored.
-     *
-     * @param inputFieldCount Number of input fields
-     * @return Mapping of a set of project expressions, never null
-     */
-    public Mappings.TargetMapping getPartialMapping(int inputFieldCount) {
-        Mappings.TargetMapping mapping =
-                Mappings.create(MappingType.INVERSE_FUNCTION, inputFieldCount, projects.size());
-        for (Ord<RexLocalRef> exp : Ord.zip(projects)) {
-            RexNode rexNode = expandLocalRef(exp.e);
-            if (rexNode instanceof RexInputRef) {
-                mapping.set(((RexInputRef) rexNode).getIndex(), exp.i);
-            }
-        }
-        return mapping;
-    }
-
-    // ~ Inner Classes ----------------------------------------------------------
-
-    /** Visitor which walks over a program and checks validity. */
-    static class Checker extends RexChecker {
-        private final List<RelDataType> internalExprTypeList;
-
-        /**
-         * Creates a Checker.
-         *
-         * @param inputRowType Types of the input fields
-         * @param internalExprTypeList Types of the internal expressions
-         * @param context Context of the enclosing {@link RelNode}, or null
-         * @param litmus Whether to fail
-         */
-        Checker(
-                RelDataType inputRowType,
-                List<RelDataType> internalExprTypeList,
-                RelNode.Context context,
-                Litmus litmus) {
-            super(inputRowType, context, litmus);
-            this.internalExprTypeList = internalExprTypeList;
-        }
-
-        /**
-         * Overrides {@link RexChecker} method, because {@link RexLocalRef} is is illegal in most
-         * rex expressions, but legal in a program.
-         */
-        @Override
-        public Boolean visitLocalRef(RexLocalRef localRef) {
-            final int index = localRef.getIndex();
-            if ((index < 0) || (index >= internalExprTypeList.size())) {
-                ++failCount;
-                return litmus.fail(null);
-            }
-            if (!RelOptUtil.eq(
-                    "type1",
-                    localRef.getType(),
-                    "type2",
-                    internalExprTypeList.get(index),
-                    litmus)) {
-                ++failCount;
-                return litmus.fail(null);
-            }
-            return litmus.succeed();
-        }
-    }
-
-    /** A RexShuttle used in the implementation of {@link RexProgram#expandLocalRef}. */
-    static class ExpansionShuttle extends RexShuttle {
-        private final List<RexNode> exprs;
-
-        ExpansionShuttle(List<RexNode> exprs) {
-            this.exprs = exprs;
-        }
-
-        @Override
-        public RexNode visitLocalRef(RexLocalRef localRef) {
-            RexNode tree = exprs.get(localRef.getIndex());
-            return tree.accept(this);
-        }
-    }
-
-    /** Walks over an expression and determines whether it is constant. */
-    private class ConstantFinder extends RexUtil.ConstantFinder {
-        @Override
-        public Boolean visitLocalRef(RexLocalRef localRef) {
-            final RexNode expr = exprs.get(localRef.index);
-            return expr.accept(this);
-        }
-
-        @Override
-        public Boolean visitOver(RexOver over) {
-            return false;
-        }
-
-        @Override
-        public Boolean visitCorrelVariable(RexCorrelVariable correlVariable) {
-            // Correlating variables are constant WITHIN A RESTART, so that's
-            // good enough.
-            return true;
-        }
-    }
-
-    /**
-     * Given an expression in a program, creates a clone of the expression with sub-expressions
-     * (represented by {@link RexLocalRef}s) fully expanded.
-     */
-    private class Marshaller extends RexVisitorImpl<@Nullable RexNode> {
-        Marshaller() {
-            super(false);
-        }
-
-        @Override
-        public RexNode visitInputRef(RexInputRef inputRef) {
-            return inputRef;
-        }
-
-        @Override
-        public @Nullable RexNode visitLocalRef(RexLocalRef localRef) {
-            final RexNode expr = exprs.get(localRef.index);
-            return expr.accept(this);
-        }
-
-        @Override
-        public RexNode visitLiteral(RexLiteral literal) {
-            return literal;
-        }
-
-        @Override
-        public RexNode visitCall(RexCall call) {
-            final List<RexNode> newOperands = new ArrayList<>();
-            for (RexNode operand : call.getOperands()) {
-                newOperands.add(castNonNull(operand.accept(this)));
-            }
-            return call.clone(call.getType(), newOperands);
-        }
-
-        @Override
-        public RexNode visitOver(RexOver over) {
-            return visitCall(over);
-        }
-
-        @Override
-        public RexNode visitCorrelVariable(RexCorrelVariable correlVariable) {
-            return correlVariable;
-        }
-
-        @Override
-        public RexNode visitDynamicParam(RexDynamicParam dynamicParam) {
-            return dynamicParam;
-        }
-
-        @Override
-        public RexNode visitRangeRef(RexRangeRef rangeRef) {
-            return rangeRef;
-        }
-
-        @Override
-        public RexNode visitFieldAccess(RexFieldAccess fieldAccess) {
-            final RexNode referenceExpr = fieldAccess.getReferenceExpr().accept(this);
-            return new RexFieldAccess(
-                    requireNonNull(referenceExpr, "referenceExpr must not be null"),
-                    fieldAccess.getField(),
-                    fieldAccess.getType());
-        }
-    }
-
-    /** Visitor which marks which expressions are used. */
-    private static class ReferenceCounter extends RexVisitorImpl<Void> {
-        private final int[] refCounts;
-
-        ReferenceCounter(int[] refCounts) {
-            super(true);
-            this.refCounts = refCounts;
-        }
-
-        @Override
-        public Void visitLocalRef(RexLocalRef localRef) {
-            final int index = localRef.getIndex();
-            refCounts[index]++;
-            return null;
-        }
-    }
-}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexShuttle.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexShuttle.java
deleted file mode 100644
index 1c753da9de3d0..0000000000000
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexShuttle.java
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.rex;
-
-import com.google.common.collect.ImmutableList;
-import org.apache.calcite.sql.SqlAggFunction;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Passes over a row-expression, calling a handler method for each node, appropriate to the type of
- * the node.
- *
- * <p>Like {@link RexVisitor}, this is an instance of the {@link
- * org.apache.calcite.util.Glossary#VISITOR_PATTERN Visitor Pattern}. Use <code> RexShuttle</code>
- * if you would like your methods to return a value.
- *
- * <p>FLINK modifications (backport of CALCITE-6764): Lines 208 ~ 211
- */
-public class RexShuttle implements RexVisitor<RexNode> {
-    // ~ Methods ----------------------------------------------------------------
-
-    @Override
-    public RexNode visitOver(RexOver over) {
-        boolean[] update = {false};
-        List<RexNode> clonedOperands = visitList(over.operands, update);
-        SqlAggFunction overAggregator = visitOverAggFunction(over.getAggOperator());
-        RexWindow window = visitWindow(over.getWindow());
-        if (update[0] || (window != over.getWindow()) || overAggregator != over.getAggOperator()) {
-            // REVIEW jvs 8-Mar-2005:  This doesn't take into account
-            // the fact that a rewrite may have changed the result type.
-            // To do that, we would need to take a RexBuilder and
-            // watch out for special operators like CAST and NEW where
-            // the type is embedded in the original call.
-            return new RexOver(
-                    over.getType(),
-                    overAggregator,
-                    clonedOperands,
-                    window,
-                    over.isDistinct(),
-                    over.ignoreNulls());
-        } else {
-            return over;
-        }
-    }
-
-    public SqlAggFunction visitOverAggFunction(SqlAggFunction op) {
-        return op;
-    }
-
-    public RexWindow visitWindow(RexWindow window) {
-        boolean[] update = {false};
-        List<RexFieldCollation> clonedOrderKeys = visitFieldCollations(window.orderKeys, update);
-        List<RexNode> clonedPartitionKeys = visitList(window.partitionKeys, update);
-        final RexWindowBound lowerBound = window.getLowerBound().accept(this);
-        final RexWindowBound upperBound = window.getUpperBound().accept(this);
-        if (!update[0]
-                && lowerBound == window.getLowerBound()
-                && upperBound == window.getUpperBound()) {
-            return window;
-        }
-        boolean rows = window.isRows();
-        if (lowerBound.isUnboundedPreceding() && upperBound.isUnboundedFollowing()) {
-            // RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
-            //   is equivalent to
-            // ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
-            //   but we prefer "RANGE"
-            rows = false;
-        }
-        return new RexWindow(
-                clonedPartitionKeys,
-                clonedOrderKeys,
-                lowerBound,
-                upperBound,
-                rows,
-                window.getExclude());
-    }
-
-    @Override
-    public RexNode visitSubQuery(RexSubQuery subQuery) {
-        boolean[] update = {false};
-        List<RexNode> clonedOperands = visitList(subQuery.operands, update);
-        if (update[0]) {
-            return subQuery.clone(subQuery.getType(), clonedOperands);
-        } else {
-            return subQuery;
-        }
-    }
-
-    @Override
-    public RexNode visitTableInputRef(RexTableInputRef ref) {
-        return ref;
-    }
-
-    @Override
-    public RexNode visitPatternFieldRef(RexPatternFieldRef fieldRef) {
-        return fieldRef;
-    }
-
-    @Override
-    public RexNode visitCall(final RexCall call) {
-        boolean[] update = {false};
-        List<RexNode> clonedOperands = visitList(call.operands, update);
-        if (update[0]) {
-            // REVIEW jvs 8-Mar-2005:  This doesn't take into account
-            // the fact that a rewrite may have changed the result type.
-            // To do that, we would need to take a RexBuilder and
-            // watch out for special operators like CAST and NEW where
-            // the type is embedded in the original call.
-            return call.clone(call.getType(), clonedOperands);
-        } else {
-            return call;
-        }
-    }
-
-    /**
-     * Visits each of an array of expressions and returns an array of the results.
-     *
-     * @param exprs Array of expressions
-     * @param update If not null, sets this to true if any of the expressions was modified
-     * @return Array of visited expressions
-     */
-    protected RexNode[] visitArray(RexNode[] exprs, boolean[] update) {
-        RexNode[] clonedOperands = new RexNode[exprs.length];
-        for (int i = 0; i < exprs.length; i++) {
-            RexNode operand = exprs[i];
-            RexNode clonedOperand = operand.accept(this);
-            if ((clonedOperand != operand) && (update != null)) {
-                update[0] = true;
-            }
-            clonedOperands[i] = clonedOperand;
-        }
-        return clonedOperands;
-    }
-
-    /**
-     * Visits each of a list of expressions and returns a list of the results.
-     *
-     * @param exprs List of expressions
-     * @param update If not null, sets this to true if any of the expressions was modified
-     * @return Array of visited expressions
-     */
-    protected List<RexNode> visitList(List<? extends RexNode> exprs, boolean[] update) {
-        ImmutableList.Builder<RexNode> clonedOperands = ImmutableList.builder();
-        for (RexNode operand : exprs) {
-            RexNode clonedOperand = operand.accept(this);
-            if ((clonedOperand != operand) && (update != null)) {
-                update[0] = true;
-            }
-            clonedOperands.add(clonedOperand);
-        }
-        return clonedOperands.build();
-    }
-
-    /**
-     * Visits each of a list of field collations and returns a list of the results.
-     *
-     * @param collations List of field collations
-     * @param update If not null, sets this to true if any of the expressions was modified
-     * @return Array of visited field collations
-     */
-    protected List<RexFieldCollation> visitFieldCollations(
-            List<RexFieldCollation> collations, boolean[] update) {
-        ImmutableList.Builder<RexFieldCollation> clonedOperands = ImmutableList.builder();
-        for (RexFieldCollation collation : collations) {
-            RexNode clonedOperand = collation.left.accept(this);
-            if ((clonedOperand != collation.left) && (update != null)) {
-                update[0] = true;
-                collation = new RexFieldCollation(clonedOperand, collation.right);
-            }
-            clonedOperands.add(collation);
-        }
-        return clonedOperands.build();
-    }
-
-    @Override
-    public RexNode visitCorrelVariable(RexCorrelVariable variable) {
-        return variable;
-    }
-
-    @Override
-    public RexNode visitFieldAccess(RexFieldAccess fieldAccess) {
-        RexNode before = fieldAccess.getReferenceExpr();
-        RexNode after = before.accept(this);
-
-        if (before == after) {
-            return fieldAccess;
-        } else {
-            return new RexFieldAccess(after, fieldAccess.getField(), fieldAccess.getType());
-        }
-    }
-
-    @Override
-    public RexNode visitInputRef(RexInputRef inputRef) {
-        return inputRef;
-    }
-
-    @Override
-    public RexNode visitLocalRef(RexLocalRef localRef) {
-        return localRef;
-    }
-
-    @Override
-    public RexNode visitLiteral(RexLiteral literal) {
-        return literal;
-    }
-
-    @Override
-    public RexNode visitDynamicParam(RexDynamicParam dynamicParam) {
-        return dynamicParam;
-    }
-
-    @Override
-    public RexNode visitRangeRef(RexRangeRef rangeRef) {
-        return rangeRef;
-    }
-
-    @Override
-    public RexNode visitLambda(RexLambda lambda) {
-        lambda.getExpression().accept(this);
-        return lambda;
-    }
-
-    @Override
-    public RexNode visitLambdaRef(RexLambdaRef lambdaRef) {
-        return lambdaRef;
-    }
-
-    /**
-     * Applies this shuttle to each expression in a list.
-     *
-     * @return whether any of the expressions changed
-     */
-    public final <T extends RexNode> boolean mutate(List<T> exprList) {
-        int changeCount = 0;
-        for (int i = 0; i < exprList.size(); i++) {
-            T expr = exprList.get(i);
-            T expr2 = (T) apply(expr); // Avoid NPE if expr is null
-            if (expr != expr2) {
-                ++changeCount;
-                exprList.set(i, expr2);
-            }
-        }
-        return changeCount > 0;
-    }
-
-    /**
-     * Applies this shuttle to each expression in a list and returns the resulting list. Does not
-     * modify the initial list.
-     *
-     * <p>Returns null if and only if {@code exprList} is null.
-     */
-    public final <T extends RexNode> List<T> apply(List<T> exprList) {
-        if (exprList == null) {
-            return exprList;
-        }
-        final List<T> list2 = new ArrayList<>(exprList);
-        if (mutate(list2)) {
-            return list2;
-        } else {
-            return exprList;
-        }
-    }
-
-    /** Applies this shuttle to an expression, or returns null if the expression is null. */
-    public final RexNode apply(RexNode expr) {
-        return (expr == null) ? expr : expr.accept(this);
-    }
-}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
index 2d70616ca966e..1ccd4a6217174 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
@@ -2492,11 +2492,9 @@ public RexNode visitFieldAccess(RexFieldAccess fieldAccess) {
             expr.accept(this);
             final RexNode normalizedExpr = lookup(expr);
             if (normalizedExpr != expr) {
-                // ----- FLINK MODIFICATION BEGIN -----
                 fieldAccess =
                         new RexFieldAccess(
                                 normalizedExpr, fieldAccess.getField(), fieldAccess.getType());
-                // ----- FLINK MODIFICATION END -----
             }
             return register(fieldAccess);
         }
@@ -2851,6 +2849,22 @@ private CorrelationFinder() {
         public Void visitCorrelVariable(RexCorrelVariable var) {
             throw Util.FoundOne.NULL;
         }
+
+        @Override
+        public Void visitSubQuery(RexSubQuery subQuery) {
+            if (!deep) {
+                return null;
+            }
+
+            for (RexNode operand : subQuery.operands) {
+                operand.accept(this);
+            }
+
+            if (!RelOptUtil.getVariablesUsed(subQuery.rel).isEmpty()) {
+                throw Util.FoundOne.NULL;
+            }
+            return null;
+        }
     }
 
     /** Shuttle that fixes up an expression to match changes in nullability of input fields. */
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
index 11c15a194fa3a..232b86c58b05a 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
@@ -45,6 +45,7 @@
 import org.apache.calcite.rel.type.TimeFrame;
 import org.apache.calcite.rel.type.TimeFrameSet;
 import org.apache.calcite.runtime.FlatLists.ComparableList;
+import org.apache.calcite.runtime.variant.VariantValue;
 import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlUtil;
 import org.apache.calcite.sql.fun.SqlLibraryOperators;
@@ -120,6 +121,7 @@
 import java.util.Objects;
 import java.util.Set;
 import java.util.TimeZone;
+import java.util.UUID;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.BinaryOperator;
 import java.util.function.Consumer;
@@ -127,6 +129,7 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
+import java.util.zip.CRC32;
 
 import static java.lang.Byte.parseByte;
 import static java.lang.Double.parseDouble;
@@ -270,12 +273,34 @@ public static boolean throwUnless(boolean condition, String message) {
         return condition;
     }
 
-    /** SQL TO_BASE64(string) function. */
+    public static String uuidToString(UUID uuid) {
+        return uuid.toString();
+    }
+
+    public static UUID binaryToUuid(ByteString bytes) {
+        if (bytes.length() < 16) {
+            throw new IllegalArgumentException("Need at least 16 bytes for UUID");
+        }
+        ByteBuffer byteBuffer = ByteBuffer.wrap(bytes.getBytes());
+        long mostSignificantBits = byteBuffer.getLong();
+        long leastSignificantBits = byteBuffer.getLong();
+        return new UUID(mostSignificantBits, leastSignificantBits);
+    }
+
+    public static ByteString uuidToBinary(UUID uuid) {
+        byte[] dest = new byte[16];
+        ByteBuffer byteBuffer = ByteBuffer.wrap(dest);
+        byteBuffer.putLong(uuid.getMostSignificantBits());
+        byteBuffer.putLong(uuid.getLeastSignificantBits());
+        return new ByteString(dest);
+    }
+
+    /** SQL TO_BASE64(string)/BASE64(string) function. */
     public static String toBase64(String string) {
         return toBase64_(string.getBytes(UTF_8));
     }
 
-    /** SQL TO_BASE64(string) function for binary string. */
+    /** SQL TO_BASE64(string)/BASE64(string) function for binary string. */
     public static String toBase64(ByteString string) {
         return toBase64_(string.getBytes());
     }
@@ -294,7 +319,7 @@ private static String toBase64_(byte[] bytes) {
         return str.substring(0, str.length() - 1);
     }
 
-    /** SQL FROM_BASE64(string) function. */
+    /** SQL FROM_BASE64(string)/UNBASE64(string) function. */
     public static @Nullable ByteString fromBase64(String base64) {
         try {
             base64 = FROM_BASE64_REGEXP.matcher(base64).replaceAll("");
@@ -338,6 +363,46 @@ public static String toHex(ByteString byteString) {
         return Hex.encodeHexString(byteString.getBytes());
     }
 
+    /** SQL HEX(varchar) function. */
+    public static String hex(String value) {
+        return Hex.encodeHexString(value.getBytes(UTF_8));
+    }
+
+    /** SQL BIN(long) function. */
+    public static String bin(long value) {
+        int zeros = Long.numberOfLeadingZeros(value);
+        if (zeros == Long.SIZE) {
+            return "0";
+        } else {
+            int length = Long.SIZE - zeros;
+            byte[] bytes = new byte[length];
+            for (int index = length - 1; index >= 0; index--) {
+                bytes[index] = (byte) ((value & 0x1) == 1 ? '1' : '0');
+                value >>>= 1;
+            }
+            // CHECKSTYLE: IGNORE 1
+            return new String(bytes, UTF_8);
+        }
+    }
+
+    /** SQL CRC32(string) function. */
+    public static long crc32(String value) {
+        final CRC32 crc32 = new CRC32();
+        crc32.reset();
+        byte[] bytes = value.getBytes(UTF_8);
+        crc32.update(bytes, 0, bytes.length);
+        return crc32.getValue();
+    }
+
+    /** SQL CRC32(string) function for binary string. */
+    public static long crc32(ByteString value) {
+        final CRC32 crc32 = new CRC32();
+        crc32.reset();
+        byte[] bytes = value.getBytes();
+        crc32.update(bytes, 0, bytes.length);
+        return crc32.getValue();
+    }
+
     /** SQL MD5(string) function. */
     public static String md5(String string) {
         return DigestUtils.md5Hex(string.getBytes(UTF_8));
@@ -953,6 +1018,26 @@ public static List<String> split(String s, String delimiter) {
         }
     }
 
+    /** SQL {@code SPLIT_PART(string, string, int)} function. */
+    public static String splitPart(String s, String delimiter, int n) {
+        if (Strings.isNullOrEmpty(s) || Strings.isNullOrEmpty(delimiter)) {
+            return "";
+        }
+
+        String[] parts = s.split(delimiter, -1);
+        int partCount = parts.length;
+
+        if (n < 0) {
+            n = partCount + n + 1;
+        }
+
+        if (n <= 0 || n > partCount) {
+            return "";
+        }
+
+        return parts[n - 1];
+    }
+
     /** SQL {@code SPLIT(string)} function. */
     public static List<String> split(String s) {
         return split(s, ",");
@@ -1692,6 +1777,31 @@ public static String translateWithCharset(String s, String transcodingName) {
         }
     }
 
+    /**
+     * Oracle's {@code CONVERT(charValue, destCharsetName[, srcCharsetName])} function, return null
+     * if s is null or empty.
+     */
+    public static String convertOracle(String s, String... args) {
+        final Charset src;
+        final Charset dest;
+        if (args.length == 1) {
+            // srcCharsetName is not specified
+            src = Charset.defaultCharset();
+            dest = SqlUtil.getCharset(args[0]);
+        } else {
+            dest = SqlUtil.getCharset(args[0]);
+            src = SqlUtil.getCharset(args[1]);
+        }
+        byte[] bytes = s.getBytes(src);
+        final CharsetDecoder decoder = dest.newDecoder();
+        final ByteBuffer buffer = ByteBuffer.wrap(bytes);
+        try {
+            return decoder.decode(buffer).toString();
+        } catch (CharacterCodingException ex) {
+            throw RESOURCE.charsetEncoding(s, dest.name()).ex();
+        }
+    }
+
     /** State for {@code PARSE_URL}. */
     @Deterministic
     public static class ParseUrlFunction {
@@ -1780,7 +1890,7 @@ public static String trim(boolean left, boolean right, String seek, String s) {
 
     public static String trim(boolean left, boolean right, String seek, String s, boolean strict) {
         if (strict && seek.length() != 1) {
-            throw RESOURCE.trimError().ex();
+            throw RESOURCE.trimError(seek).ex();
         }
         int j = s.length();
         if (right) {
@@ -2408,6 +2518,40 @@ public static Object plusAny(Object b0, Object b1) {
         throw notArithmetic("+", b0, b1);
     }
 
+    // checked +
+
+    static byte intToByte(int value) {
+        if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
+            throw new ArithmeticException(
+                    "integer overflow: Value " + value + " does not fit in a TINYINT");
+        }
+        return (byte) value;
+    }
+
+    static short intToShort(int value) {
+        if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
+            throw new ArithmeticException(
+                    "integer overflow: Value " + value + " does not fit in a SMALLINT");
+        }
+        return (short) value;
+    }
+
+    public static byte checkedPlus(byte b0, byte b1) {
+        return intToByte(b0 + b1);
+    }
+
+    public static short checkedPlus(short b0, short b1) {
+        return intToShort(b0 + b1);
+    }
+
+    public static int checkedPlus(int b0, int b1) {
+        return Math.addExact(b0, b1);
+    }
+
+    public static long checkedPlus(long b0, long b1) {
+        return Math.addExact(b0, b1);
+    }
+
     // -
 
     /** SQL <code>-</code> operator applied to int values. */
@@ -2461,6 +2605,40 @@ public static Object minusAny(Object b0, Object b1) {
         throw notArithmetic("-", b0, b1);
     }
 
+    // checked -
+
+    public static byte checkedMinus(byte b0, byte b1) {
+        return intToByte(b0 - b1);
+    }
+
+    public static short checkedMinus(short b0, short b1) {
+        return intToShort(b0 - b1);
+    }
+
+    public static int checkedMinus(int b0, int b1) {
+        return Math.subtractExact(b0, b1);
+    }
+
+    public static long checkedMinus(long b0, long b1) {
+        return Math.subtractExact(b0, b1);
+    }
+
+    public static byte checkedUnaryMinus(byte b) {
+        return intToByte(-b);
+    }
+
+    public static short checkedUnaryMinus(short b) {
+        return intToShort(-b);
+    }
+
+    public static int checkedUnaryMinus(int b) {
+        return Math.subtractExact(0, b);
+    }
+
+    public static long checkedUnaryMinus(long b) {
+        return Math.subtractExact(0, b);
+    }
+
     // /
 
     /** SQL <code>/</code> operator applied to int values. */
@@ -2524,6 +2702,34 @@ public static long divide(long b0, BigDecimal b1) {
         return BigDecimal.valueOf(b0).divide(b1, RoundingMode.HALF_DOWN).longValue();
     }
 
+    public static byte checkedDivide(byte b0, byte b1) {
+        return intToByte(b0 / b1);
+    }
+
+    public static short checkedDivide(short b0, short b1) {
+        return intToShort(b0 / b1);
+    }
+
+    public static int checkedDivide(int b0, int b1) {
+        // Implementation taken from Java 19
+        int q = b0 / b1;
+        if ((b0 & b1 & q) >= 0) {
+            return q;
+        } else {
+            throw new ArithmeticException("integer overflow");
+        }
+    }
+
+    public static long checkedDivide(long b0, long b1) {
+        // Implementation taken from Java 19
+        long q = b0 / b1;
+        if ((b0 & b1 & q) >= 0) {
+            return q;
+        } else {
+            throw new ArithmeticException("integer overflow");
+        }
+    }
+
     // *
 
     /** SQL <code>*</code> operator applied to int values. */
@@ -2577,6 +2783,24 @@ public static Object multiplyAny(Object b0, Object b1) {
         throw notArithmetic("*", b0, b1);
     }
 
+    // checked *
+
+    public static byte checkedMultiply(byte b0, byte b1) {
+        return intToByte(b0 * b1);
+    }
+
+    public static short checkedMultiply(short b0, short b1) {
+        return intToShort(b0 * b1);
+    }
+
+    public static int checkedMultiply(int b0, int b1) {
+        return Math.multiplyExact(b0, b1);
+    }
+
+    public static long checkedMultiply(long b0, long b1) {
+        return Math.multiplyExact(b0, b1);
+    }
+
     /** SQL <code>SAFE_ADD</code> function applied to long values. */
     public static @Nullable Long safeAdd(long b0, long b1) {
         try {
@@ -2912,6 +3136,58 @@ public static long bitCount(ByteString b) {
         return bitsSet;
     }
 
+    /**
+     * Helper function for implementing MySQL <code>BIT_COUNT</code>. Counts the number of bits set
+     * in a boolean value.
+     */
+    public static long bitCountMySQL(Boolean b) {
+        return Long.bitCount(b ? 1L : 0L);
+    }
+
+    /**
+     * Helper function for implementing MySQL <code>BIT_COUNT</code>. Counts the number of bits set
+     * in a string value.
+     */
+    public static long bitCountMySQL(String b) {
+        try {
+            return bitCount(new BigDecimal(b));
+        } catch (Exception ignore) {
+            return 0;
+        }
+    }
+
+    /**
+     * Helper function for implementing MySQL <code>BIT_COUNT</code>. Counts the number of bits set
+     * in a number value.
+     */
+    public static long bitCountMySQL(Number b) {
+        return bitCount(new BigDecimal(b.toString()));
+    }
+
+    /**
+     * Helper function for implementing MySQL <code>BIT_COUNT</code>. Counts the number of bits set
+     * in a date value.
+     */
+    public static long bitCountMySQL(java.sql.Date b) {
+        return bitCountMySQL(new SimpleDateFormat("yyyyMMdd", Locale.ENGLISH).format(b));
+    }
+
+    /**
+     * Helper function for implementing MySQL <code>BIT_COUNT</code>. Counts the number of bits set
+     * in a time value.
+     */
+    public static long bitCountMySQL(Time b) {
+        return bitCountMySQL(new SimpleDateFormat("HHmmss", Locale.ENGLISH).format(b));
+    }
+
+    /**
+     * Helper function for implementing MySQL <code>BIT_COUNT</code>. Counts the number of bits set
+     * in a timestamp value.
+     */
+    public static long bitCountMySQL(Timestamp b) {
+        return bitCountMySQL(new SimpleDateFormat("yyyyMMddHHmmss", Locale.ENGLISH).format(b));
+    }
+
     /** Bitwise function <code>BIT_OR</code> applied to integer values. */
     public static long bitOr(long b0, long b1) {
         return b0 | b1;
@@ -3802,12 +4078,18 @@ public static double sec(double b0) {
     // Helpers
 
     /** Helper for implementing MIN. Somewhat similar to LEAST operator. */
-    public static <T extends Comparable<T>> T lesser(T b0, T b1) {
-        return b0 == null || b0.compareTo(b1) > 0 ? b1 : b0;
+    public static @Nullable <T extends Comparable<T>> T lesser(@Nullable T b0, @Nullable T b1) {
+        if (b0 == null) {
+            return b1;
+        }
+        if (b1 == null) {
+            return b0;
+        }
+        return b0.compareTo(b1) > 0 ? b1 : b0;
     }
 
     /** LEAST operator. */
-    public static <T extends Comparable<T>> T least(T b0, T b1) {
+    public static @Nullable <T extends Comparable<T>> T least(@Nullable T b0, @Nullable T b1) {
         return b0 == null || b1 != null && b0.compareTo(b1) > 0 ? b1 : b0;
     }
 
@@ -3875,13 +4157,41 @@ public static double lesser(double b0, double b1) {
         return b0 > b1 ? b1 : b0;
     }
 
+    public static @Nullable <T extends Comparable<T>> List<T> lesser(
+            @Nullable List<T> b0, @Nullable List<T> b1) {
+        if (b0 == null) {
+            return b1;
+        }
+        if (b1 == null) {
+            return b0;
+        }
+        return lt(b0, b1) ? b0 : b1;
+    }
+
+    public static @Nullable <T extends Comparable<T>> List<T> greater(
+            @Nullable List<T> b0, @Nullable List<T> b1) {
+        if (b0 == null) {
+            return b1;
+        }
+        if (b1 == null) {
+            return b0;
+        }
+        return gt(b0, b1) ? b0 : b1;
+    }
+
     /** Helper for implementing MAX. Somewhat similar to GREATEST operator. */
-    public static <T extends Comparable<T>> T greater(T b0, T b1) {
-        return b0 == null || b0.compareTo(b1) < 0 ? b1 : b0;
+    public static @Nullable <T extends Comparable<T>> T greater(@Nullable T b0, @Nullable T b1) {
+        if (b0 == null) {
+            return b1;
+        }
+        if (b1 == null) {
+            return b0;
+        }
+        return b0.compareTo(b1) < 0 ? b1 : b0;
     }
 
     /** GREATEST operator. */
-    public static <T extends Comparable<T>> T greatest(T b0, T b1) {
+    public static @Nullable <T extends Comparable<T>> T greatest(@Nullable T b0, @Nullable T b1) {
         return b0 == null || b1 != null && b0.compareTo(b1) < 0 ? b1 : b0;
     }
 
@@ -4072,6 +4382,10 @@ public static Integer toIntOptional(java.sql.Time v) {
         return v == null ? castNonNull(null) : toInt(v);
     }
 
+    // Method tagged as non-deterministic because it can throw.
+    // The DeterministicCodeOptimizer may otherwise try to lift it out of try-catch blocks.
+    // See https://issues.apache.org/jira/browse/CALCITE-6753
+    @NonDeterministic
     public static int toInt(String s) {
         return parseInt(s.trim());
     }
@@ -5379,6 +5693,32 @@ public static int localTime(DataContext root) {
         return timestampToTime(localTimestamp(root));
     }
 
+    /** SQL {@code SYSTIMESTAMP} function. */
+    @NonDeterministic
+    public static long sysTimestamp(DataContext root) {
+        return DataContext.Variable.SYS_TIMESTAMP.get(root);
+    }
+
+    /**
+     * SQL {@code SYSDATE} function.
+     *
+     * <p>When the date is before 1970-01-01 00:00:00, for example: 1969-12-31 23:59:59, the
+     * timestamp will return a negative value, such as -1000. The date(days since epoch) returned by
+     * timestampToDate(-1000) is 0, so we need to additionally judge the result of
+     * timestampToTime(-1000). If its value is less than 0, we need to reduce date by 1 to ensure
+     * the accuracy of date.
+     */
+    @NonDeterministic
+    public static int sysDate(DataContext root) {
+        final long timestamp = sysTimestamp(root);
+        int date = timestampToDate(timestamp);
+        final int time = timestampToTime(timestamp);
+        if (time < 0) {
+            --date;
+        }
+        return date;
+    }
+
     @NonDeterministic
     public static TimeZone timeZone(DataContext root) {
         return DataContext.Variable.TIME_ZONE.get(root);
@@ -5509,8 +5849,16 @@ public static String translate3(String s, String search, String replacement) {
     }
 
     /** SQL {@code REPLACE(string, search, replacement)} function. */
-    public static String replace(String s, String search, String replacement) {
-        return s.replace(search, replacement);
+    public static String replace(
+            String s, String search, String replacement, boolean isCaseSensitive) {
+        if (search.isEmpty()) {
+            return s;
+        }
+        if (isCaseSensitive) {
+            return s.replace(search, replacement);
+        }
+        // for MSSQL's REPLACE function, search pattern is case-insensitive during matching
+        return org.apache.commons.lang3.StringUtils.replaceIgnoreCase(s, search, replacement);
     }
 
     /**
@@ -5547,6 +5895,9 @@ public static String replace(String s, String search, String replacement) {
      * Implements the {@code [ ... ]} operator on an object whose type is not known until runtime.
      */
     public static @Nullable Object item(Object object, Object index) {
+        if (object instanceof VariantValue) {
+            return ((VariantValue) object).item(index);
+        }
         if (object instanceof Map) {
             return mapItem((Map) object, index);
         }
@@ -6212,6 +6563,15 @@ public static List reverse(List list) {
         return list;
     }
 
+    /** SQL {@code ARRAY_SLICE(array, start, length)} function. */
+    public static List arraySlice(List list, int start, int length) {
+        // return empty list if start/length are out of range of the array
+        if (start + length > list.size()) {
+            return Collections.emptyList();
+        }
+        return list.subList(start, start + length);
+    }
+
     /** SQL {@code ARRAY_TO_STRING(array, delimiter)} function. */
     public static String arrayToString(List list, String delimiter) {
         return arrayToString(list, delimiter, null);
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java
index 3f2e070228a95..f6ebfe9df4f2f 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java
@@ -315,6 +315,7 @@ public static void unparseFunctionSyntax(
                     // when it has 0 args, not "LOCALTIME()".
                     return;
                 case FUNCTION_STAR: // E.g. "COUNT(*)"
+                case FUNCTION_ID_CONSTANT: // E.g. "PI()"
                 case FUNCTION: // E.g. "RANK()"
                 case ORDERED_FUNCTION: // E.g. "STRING_AGG(x)"
                     // fall through - dealt with below
@@ -382,7 +383,9 @@ public static void unparseSqlIdentifierSyntax(
             // look up in the standard sql operator table to see if it is a function
             // with empty argument list, e.g. LOCALTIME, we should not quote
             // such identifier cause quoted `LOCALTIME` always represents a sql identifier.
-            if (asFunctionID || operator.getSyntax() == SqlSyntax.FUNCTION_ID) {
+            if (asFunctionID
+                    || operator.getSyntax() == SqlSyntax.FUNCTION_ID
+                    || operator.getSyntax() == SqlSyntax.FUNCTION_ID_CONSTANT) {
                 writer.keyword(identifier.getSimple());
                 unparsedAsFunc = true;
             }
@@ -1023,7 +1026,6 @@ public static Charset getCharset(String charsetName) {
      * @param charset charset
      * @throws RuntimeException If the given value cannot be represented in the given charset
      */
-    @SuppressWarnings("BetaApi")
     public static void validateCharset(ByteString value, Charset charset) {
         if (charset == StandardCharsets.UTF_8) {
             final byte[] bytes = value.getBytes();
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java
index 4e691ddf27f5f..7222d74ed7b21 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java
@@ -141,7 +141,7 @@ protected static void checkPrecScale(
     // ~ Methods ----------------------------------------------------------------
 
     /** Constructs a type with nullablity. */
-    BasicSqlType createWithNullability(boolean nullable) {
+    public BasicSqlType createWithNullability(boolean nullable) {
         if (nullable == this.isNullable) {
             return this;
         }
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java
index 75380a252d928..7975e6ed40e9c 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java
@@ -14,7 +14,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.apache.calcite.sql.type;
 
 import com.google.common.collect.ImmutableMap;
@@ -213,6 +212,9 @@ private SqlTypeAssignmentRule(Map<SqlTypeName, ImmutableSet<SqlTypeName>> map) {
         rules.add(SqlTypeName.COLUMN_LIST, EnumSet.of(SqlTypeName.COLUMN_LIST));
         // ----- FLINK MODIFICATION END -----
 
+        // UUID is assignable from
+        rules.add(SqlTypeName.UUID, EnumSet.of(SqlTypeName.UUID));
+
         // ANY is assignable from ...
         rule.clear();
         rule.add(SqlTypeName.TINYINT);
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
index ed808ead90eea..6e564abe68e47 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
@@ -29,6 +29,7 @@
 import java.nio.charset.Charset;
 import java.util.List;
 
+import static com.google.common.base.Preconditions.checkArgument;
 import static java.util.Objects.requireNonNull;
 import static org.apache.calcite.util.Static.RESOURCE;
 
@@ -67,7 +68,7 @@ public RelDataType createSqlType(SqlTypeName typeName) {
     @Override
     public RelDataType createSqlType(SqlTypeName typeName, int precision) {
         if (typeName.allowsScale()) {
-            return createSqlType(typeName, precision, typeName.getDefaultScale());
+            return createSqlType(typeName, precision, typeSystem.getDefaultScale(typeName));
         }
         final int maxPrecision = typeSystem.getMaxPrecision(typeName);
         if (maxPrecision >= 0 && precision > maxPrecision) {
@@ -84,24 +85,27 @@ public RelDataType createSqlType(SqlTypeName typeName, int precision) {
         return canonize(newType);
     }
 
+    @SuppressWarnings("deprecation") // [CALCITE-6598]
     @Override
     public RelDataType createSqlType(SqlTypeName typeName, int precision, int scale) {
         assertBasic(typeName);
         assert (precision >= 0) || (precision == RelDataType.PRECISION_NOT_SPECIFIED);
-        final int maxPrecision = typeSystem.getMaxPrecision(typeName);
-        if (maxPrecision >= 0 && precision > maxPrecision) {
-            precision = maxPrecision;
-        }
-        if (precision != RelDataType.PRECISION_NOT_SPECIFIED
-                && precision < typeSystem.getMinPrecision(typeName)) {
-            throw RESOURCE.invalidPrecisionForDecimalType(precision, maxPrecision).ex();
+        if (precision != RelDataType.PRECISION_NOT_SPECIFIED) {
+            final int minPrecision = typeSystem.getMinPrecision(typeName);
+            final int maxPrecision = typeSystem.getMaxPrecision(typeName);
+            if (maxPrecision >= 0 && precision > maxPrecision) {
+                precision = maxPrecision;
+            }
+            if (precision < minPrecision) {
+                throw RESOURCE.invalidPrecisionForDecimalType(precision, maxPrecision).ex();
+            }
         }
-        if (scale != RelDataType.SCALE_NOT_SPECIFIED && scale < typeSystem.getMinScale(typeName)) {
-            throw RESOURCE.invalidScaleForDecimalType(
-                            scale,
-                            typeSystem.getMinScale(typeName),
-                            typeSystem.getMaxNumericScale())
-                    .ex();
+        if (scale != RelDataType.SCALE_NOT_SPECIFIED) {
+            final int minScale = typeSystem.getMinScale(typeName);
+            final int maxScale = typeSystem.getMaxNumericScale();
+            if (scale < minScale) {
+                throw RESOURCE.invalidScaleForDecimalType(scale, minScale, maxScale).ex();
+            }
         }
         RelDataType newType = new BasicSqlType(typeSystem, typeName, precision, scale);
         newType = SqlTypeUtil.addCharsetAndCollation(newType, this);
@@ -110,9 +114,7 @@ public RelDataType createSqlType(SqlTypeName typeName, int precision, int scale)
 
     @Override
     public RelDataType createUnknownType() {
-        // FLINK MODIFICATION BEGIN
-        return canonize(new UnknownSqlType(this));
-        // FLINK MODIFICATION END
+        return createSqlType(SqlTypeName.UNKNOWN);
     }
 
     @Override
@@ -174,9 +176,11 @@ public RelDataType createTypeWithCharsetAndCollation(
     }
 
     @Override
-    public @Nullable RelDataType leastRestrictive(List<RelDataType> types) {
-        assert types != null;
-        assert types.size() >= 1;
+    public @Nullable RelDataType leastRestrictive(
+            List<RelDataType> types, SqlTypeMappingRule mappingRule) {
+        requireNonNull(types, "types");
+        requireNonNull(mappingRule, "mappingRule");
+        checkArgument(types.size() >= 1, "types.size >= 1");
 
         RelDataType type0 = types.get(0);
         if (type0.getSqlTypeName() != null) {
@@ -184,13 +188,14 @@ public RelDataType createTypeWithCharsetAndCollation(
             if (resultType != null) {
                 return resultType;
             }
-            return leastRestrictiveByCast(types);
+            return leastRestrictiveByCast(types, mappingRule);
         }
 
-        return super.leastRestrictive(types);
+        return super.leastRestrictive(types, mappingRule);
     }
 
-    private @Nullable RelDataType leastRestrictiveByCast(List<RelDataType> types) {
+    private @Nullable RelDataType leastRestrictiveByCast(
+            List<RelDataType> types, SqlTypeMappingRule mappingRule) {
         RelDataType resultType = types.get(0);
         boolean anyNullable = resultType.isNullable();
         for (int i = 1; i < types.size(); i++) {
@@ -204,10 +209,10 @@ public RelDataType createTypeWithCharsetAndCollation(
                 anyNullable = true;
             }
 
-            if (SqlTypeUtil.canCastFrom(type, resultType, false)) {
+            if (SqlTypeUtil.canCastFrom(type, resultType, mappingRule)) {
                 resultType = type;
             } else {
-                if (!SqlTypeUtil.canCastFrom(resultType, type, false)) {
+                if (!SqlTypeUtil.canCastFrom(resultType, type, mappingRule)) {
                     return null;
                 }
             }
@@ -240,8 +245,6 @@ public RelDataType createTypeWithNullability(final RelDataType type, final boole
         return canonize(newType);
     }
 
-    // ----- FLINK MODIFICATION BEGIN -----
-    // Backport from Calcite (CALCITE-6764)
     @Override
     public RelDataType enforceTypeWithNullability(final RelDataType type, final boolean nullable) {
         final RelDataType newType;
@@ -263,8 +266,6 @@ public RelDataType enforceTypeWithNullability(final RelDataType type, final bool
         return canonize(newType);
     }
 
-    // ----- FLINK MODIFICATION END -----
-
     private static void assertBasic(SqlTypeName typeName) {
         assert typeName != null;
         assert typeName != SqlTypeName.MULTISET : "use createMultisetType() instead";
@@ -275,6 +276,7 @@ private static void assertBasic(SqlTypeName typeName) {
                 : "use createSqlIntervalType() instead";
     }
 
+    @SuppressWarnings("deprecation") // [CALCITE-6598]
     private @Nullable RelDataType leastRestrictiveSqlType(List<RelDataType> types) {
         RelDataType resultType = null;
         int nullCount = 0;
@@ -525,9 +527,8 @@ private static void assertBasic(SqlTypeName typeName) {
                 }
 
                 // FLINK MODIFICATION BEGIN
-                // in case we compare TIME(STAMP) and TIME(STAMP)_LTZ we should adjust the precision
-                // as well
                 if (type.getSqlTypeName().getFamily() == resultType.getSqlTypeName().getFamily()
+                        // FLINK MODIFICATION END
                         && type.getSqlTypeName().allowsPrec()
                         && type.getPrecision() != resultType.getPrecision()) {
                     final int precision =
@@ -536,7 +537,6 @@ private static void assertBasic(SqlTypeName typeName) {
 
                     resultType = createSqlType(type.getSqlTypeName(), precision);
                 }
-                // FLINK MODIFICATION END
             } else {
                 return null;
             }
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
index 94ac1cd34d3d2..2aa111e918a81 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
@@ -89,7 +89,7 @@ public abstract class SqlTypeUtil {
      *     same charset and collation of same charset
      */
     public static boolean isCharTypeComparable(List<RelDataType> argTypes) {
-        assert argTypes != null;
+        requireNonNull(argTypes, "argTypes");
         assert argTypes.size() >= 2;
 
         // Filter out ANY and NULL elements.
@@ -574,17 +574,34 @@ public static boolean sameNamedType(RelDataType t1, RelDataType t2) {
             }
             return true;
         }
-        RelDataType comp1 = t1.getComponentType();
-        RelDataType comp2 = t2.getComponentType();
-        if ((comp1 != null) || (comp2 != null)) {
-            if ((comp1 == null) || (comp2 == null)) {
+        SqlTypeName t1Name = t1.getSqlTypeName();
+        SqlTypeName t2Name = t2.getSqlTypeName();
+        if (t1Name == SqlTypeName.ARRAY || t1Name == SqlTypeName.MULTISET) {
+            if (t1Name != t2Name) {
                 return false;
             }
-            if (!sameNamedType(comp1, comp2)) {
+
+            RelDataType comp1 = requireNonNull(t1.getComponentType());
+            RelDataType comp2 = requireNonNull(t2.getComponentType());
+            return sameNamedType(comp1, comp2);
+        }
+
+        if (t1Name == SqlTypeName.MAP) {
+            if (t1Name != t2Name) {
+                return false;
+            }
+
+            RelDataType keyType1 = requireNonNull(t1.getKeyType());
+            RelDataType keyType2 = requireNonNull(t2.getKeyType());
+            if (!sameNamedType(keyType1, keyType2)) {
                 return false;
             }
+            RelDataType valueType1 = requireNonNull(t1.getValueType());
+            RelDataType valueType2 = requireNonNull(t2.getValueType());
+            return sameNamedType(valueType1, valueType2);
         }
-        return t1.getSqlTypeName() == t2.getSqlTypeName();
+
+        return t1Name == t2Name;
     }
 
     /**
@@ -751,6 +768,10 @@ private static boolean isAny(RelDataType t) {
         return t.getFamily() == SqlTypeFamily.ANY;
     }
 
+    private static boolean isVariant(RelDataType t) {
+        return t.getFamily() == SqlTypeFamily.VARIANT;
+    }
+
     public static boolean isMeasure(RelDataType t) {
         return t instanceof MeasureSqlType;
     }
@@ -861,7 +882,7 @@ public static boolean canCastFrom(
             return canCastFrom(
                     toType, requireNonNull(fromType.getMeasureElementType()), typeMappingRule);
         }
-        if (isAny(toType) || isAny(fromType)) {
+        if (isAny(toType) || isAny(fromType) || isVariant(toType) || isVariant(fromType)) {
             return true;
         }
 
@@ -870,6 +891,11 @@ public static boolean canCastFrom(
         if (toTypeName == SqlTypeName.UNKNOWN) {
             return true;
         }
+        if (toType.getSqlTypeName() == SqlTypeName.UUID) {
+            return fromType.getSqlTypeName() == SqlTypeName.UUID
+                    || fromType.getFamily() == SqlTypeFamily.CHARACTER
+                    || fromType.getFamily() == SqlTypeFamily.BINARY;
+        }
         if (toType.isStruct() || fromType.isStruct()) {
             if (toTypeName == SqlTypeName.DISTINCT) {
                 if (fromTypeName == SqlTypeName.DISTINCT) {
@@ -1049,7 +1075,7 @@ public static SqlDataTypeSpec convertTypeToSpec(
 
         // TODO jvs 28-Dec-2004:  support row types, user-defined types,
         // interval types, multiset types, etc
-        assert typeName != null;
+        requireNonNull(typeName, "typeName");
 
         final SqlTypeNameSpec typeNameSpec;
         if (isAtomic(type)
@@ -1432,6 +1458,15 @@ public static boolean isFlat(RelDataType type) {
      * @return Whether types are comparable
      */
     public static boolean isComparable(RelDataType type1, RelDataType type2) {
+        // FLINK MODIFICATION BEGIN Calcite-7230
+        final RelDataTypeFamily family1 = family(type1);
+        final RelDataTypeFamily family2 = family(type2);
+
+        // If one of the arguments is of type 'NULL', return true.
+        if (family1 == SqlTypeFamily.NULL || family2 == SqlTypeFamily.NULL) {
+            return true;
+        }
+        // FLINK MODIFICATION END
         if (type1.isStruct() != type2.isStruct()) {
             return false;
         }
@@ -1450,8 +1485,28 @@ public static boolean isComparable(RelDataType type1, RelDataType type2) {
             return true;
         }
 
-        final RelDataTypeFamily family1 = family(type1);
-        final RelDataTypeFamily family2 = family(type2);
+        SqlTypeName type1Name = type1.getSqlTypeName();
+        SqlTypeName type2Name = type2.getSqlTypeName();
+        if (type1Name == SqlTypeName.ARRAY || type1Name == SqlTypeName.MULTISET) {
+            if (type2Name != type1Name) {
+                return false;
+            }
+            RelDataType elementType1 = requireNonNull(type1.getComponentType());
+            RelDataType elementType2 = requireNonNull(type2.getComponentType());
+            return isComparable(elementType1, elementType2);
+        }
+
+        if (type1Name == SqlTypeName.MAP) {
+            if (type2Name != type1Name) {
+                return false;
+            }
+            RelDataType keyType1 = requireNonNull(type1.getKeyType());
+            RelDataType keyType2 = requireNonNull(type2.getKeyType());
+            RelDataType valueType1 = requireNonNull(type1.getValueType());
+            RelDataType valueType2 = requireNonNull(type2.getValueType());
+            return isComparable(keyType1, keyType2) && isComparable(valueType1, valueType2);
+        }
+
         if (family1 == family2) {
             return true;
         }
@@ -1467,12 +1522,8 @@ public static boolean isComparable(RelDataType type1, RelDataType type2) {
         }
 
         // We can implicitly convert from character to date
-        if (family1 == SqlTypeFamily.CHARACTER && canConvertStringInCompare(family2)
-                || family2 == SqlTypeFamily.CHARACTER && canConvertStringInCompare(family1)) {
-            return true;
-        }
-
-        return false;
+        return family1 == SqlTypeFamily.CHARACTER && canConvertStringInCompare(family2)
+                || family2 == SqlTypeFamily.CHARACTER && canConvertStringInCompare(family1);
     }
 
     /**
@@ -1760,6 +1811,7 @@ public static boolean isAtomic(RelDataType type) {
     }
 
     /** Returns a DECIMAL type with the maximum precision for the current type system. */
+    @SuppressWarnings("deprecation") // [CALCITE-6598]
     public static RelDataType getMaxPrecisionScaleDecimal(RelDataTypeFactory factory) {
         int maxPrecision = factory.getTypeSystem().getMaxNumericPrecision();
         int maxScale = factory.getTypeSystem().getMaxNumericScale();
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index e100df7031579..108df341d2656 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -33,7 +33,6 @@
 import org.apache.calcite.rel.type.RelCrossType;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.calcite.rel.type.RelDataTypeFactoryImpl;
 import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.rel.type.RelDataTypeSystem;
 import org.apache.calcite.rel.type.RelRecordType;
@@ -134,6 +133,7 @@
 import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.checker.nullness.qual.PolyNull;
+import org.checkerframework.checker.nullness.qual.RequiresNonNull;
 import org.checkerframework.dataflow.qual.Pure;
 import org.slf4j.Logger;
 
@@ -163,7 +163,7 @@
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
+import java.util.stream.Stream;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkState;
@@ -1196,15 +1196,27 @@ protected void validateNamespace(
             RelDataType type = namespace.getType();
 
             if (node == top) {
-                // A top-level namespace must not return any must-filter fields.
+                final FilterRequirement filterRequirement = namespace.getFilterRequirement();
+
+                // Either of the following two conditions result in an invalid query:
+                // 1) A top-level namespace must not return any must-filter fields.
                 // A non-top-level namespace (e.g. a subquery) may return must-filter
                 // fields; these are neutralized if the consuming query filters on them.
-                final ImmutableBitSet mustFilterFields = namespace.getMustFilterFields();
-                if (!mustFilterFields.isEmpty()) {
+                // 2) A top-level namespace must not have any remnant-must-filter fields.
+                // Remnant must filter fields are fields that are not selected and cannot
+                // be defused unless a bypass field defuses it.
+                if (!filterRequirement.filterFields.isEmpty()
+                        || !filterRequirement.remnantFilterFields.isEmpty()) {
+                    Stream<String> mustFilterStream =
+                            filterRequirement.filterFields.stream()
+                                    .mapToObj(namespace.getRowType().getFieldNames()::get);
+                    Stream<String> remnantStream =
+                            filterRequirement.remnantFilterFields.stream()
+                                    .map(q -> q.suffix().get(0));
+
                     // Set of field names, sorted alphabetically for determinism.
                     Set<String> fieldNameSet =
-                            StreamSupport.stream(mustFilterFields.spliterator(), false)
-                                    .map(namespace.getRowType().getFieldNames()::get)
+                            Stream.concat(mustFilterStream, remnantStream)
                                     .collect(Collectors.toCollection(TreeSet::new));
                     throw newValidationError(
                             node, RESOURCE.mustFilterFieldsMissing(fieldNameSet.toString()));
@@ -2012,19 +2024,31 @@ public void removeValidatedNodeType(SqlNode node) {
 
     @Override
     public @Nullable SqlCall makeNullaryCall(SqlIdentifier id) {
-        if (id.names.size() == 1 && !id.isComponentQuoted(0)) {
+        if (!id.isComponentQuoted(id.names.size() - 1)) {
             final List<SqlOperator> list = new ArrayList<>();
             opTab.lookupOperatorOverloads(
                     id, null, SqlSyntax.FUNCTION, list, catalogReader.nameMatcher());
             for (SqlOperator operator : list) {
-                if (operator.getSyntax() == SqlSyntax.FUNCTION_ID) {
+                if (operator.getSyntax() == SqlSyntax.FUNCTION_ID
+                        || operator.getSyntax() == SqlSyntax.FUNCTION_ID_CONSTANT) {
                     // Even though this looks like an identifier, it is a
                     // actually a call to a function. Construct a fake
                     // call to this function, so we can use the regular
                     // operator validation.
-                    return new SqlBasicCall(
-                                    operator, ImmutableList.of(), id.getParserPosition(), null)
-                            .withExpanded(true);
+                    SqlCall sqlCall =
+                            new SqlBasicCall(
+                                            operator,
+                                            ImmutableList.of(),
+                                            id.getParserPosition(),
+                                            null)
+                                    .withExpanded(true);
+                    if (operator.getSyntax() == SqlSyntax.FUNCTION_ID_CONSTANT
+                            && !this.config
+                                    .conformance()
+                                    .allowNiladicConstantWithoutParentheses()) {
+                        throw handleUnresolvedFunction(sqlCall, operator, ImmutableList.of(), null);
+                    }
+                    return sqlCall;
                 }
             }
         }
@@ -2124,7 +2148,9 @@ public CalciteException handleUnresolvedFunction(
                 catalogReader.nameMatcher());
         if (overloads.size() == 1) {
             SqlFunction fun = (SqlFunction) overloads.get(0);
-            if ((fun.getSqlIdentifier() == null) && (fun.getSyntax() != SqlSyntax.FUNCTION_ID)) {
+            if ((fun.getSqlIdentifier() == null)
+                    && (fun.getSyntax() != SqlSyntax.FUNCTION_ID
+                            && fun.getSyntax() != SqlSyntax.FUNCTION_ID_CONSTANT)) {
                 final int expectedArgCount = fun.getOperandCountRange().getMin();
                 throw newValidationError(
                         call,
@@ -3428,6 +3454,7 @@ public void validateIdentifier(SqlIdentifier id, SqlValidatorScope scope) {
         }
     }
 
+    @SuppressWarnings("deprecation") // [CALCITE-6598]
     @Override
     public void validateLiteral(SqlLiteral literal) {
         switch (literal.getTypeName()) {
@@ -3863,6 +3890,13 @@ private CompareFromBothSides(
                 boolean rightFound = false;
                 // The two sides of the comparison must be from different tables
                 for (SqlNode operand : call.getOperandList()) {
+                    if (operand instanceof SqlBasicCall) {
+                        SqlBasicCall basicCall = (SqlBasicCall) operand;
+                        if (basicCall.getKind() == SqlKind.CAST) {
+                            // Allow casts applied to identifiers
+                            operand = basicCall.operand(0);
+                        }
+                    }
                     if (!(operand instanceof SqlIdentifier)) {
                         throw newValidationError(call, this.exception);
                     }
@@ -3897,11 +3931,14 @@ private CompareFromBothSides(
         }
     }
 
-    /** Shuttle which determines whether an expression is a simple conjunction of equalities. */
+    /**
+     * Shuttle which determines whether an expression is a simple conjunction of equalities. Each
+     * equality may involve a cast
+     */
     private static class ConjunctionOfEqualities extends SqlShuttle {
         boolean illegal = false;
 
-        // Check an AND node.  Children can be AND nodes or EQUAL nodes.
+        // Check an AND node. Children can be AND nodes or EQUAL nodes.
         void checkAnd(SqlCall call) {
             // This doesn't seem to use the visitor pattern,
             // because we recurse explicitly on the tree structure.
@@ -3920,14 +3957,23 @@ void checkAnd(SqlCall call) {
         }
 
         @Override
-        public @Nullable SqlNode visit(final org.apache.calcite.sql.SqlCall call) {
+        public @Nullable SqlNode visit(final SqlCall call) {
             SqlKind kind = call.getKind();
-            if (kind != SqlKind.AND && kind != SqlKind.EQUALS) {
+            if (kind != SqlKind.AND && kind != SqlKind.EQUALS && kind != SqlKind.CAST) {
                 illegal = true;
+                return null;
             }
             if (kind == SqlKind.AND) {
                 this.checkAnd(call);
             }
+            if (kind == SqlKind.CAST) {
+                // Cast must be applied directly to a column
+                SqlNode operand = call.operand(0);
+                if (!(operand instanceof SqlIdentifier)) {
+                    illegal = true;
+                    return null;
+                }
+            }
             return super.visit(call);
         }
     }
@@ -4093,7 +4139,6 @@ protected void validateSelect(SqlSelect select, RelDataType targetRowType) {
 
         validateWhereClause(select);
         validateGroupClause(select);
-        validateHavingClause(select);
         validateWindowClause(select);
         validateQualifyClause(select);
         handleOffsetFetch(select.getOffset(), select.getFetch());
@@ -4103,72 +4148,9 @@ protected void validateSelect(SqlSelect select, RelDataType targetRowType) {
         // window name in the WINDOW clause etc.
         final RelDataType rowType = validateSelectList(selectItems, select, targetRowType);
         ns.setType(rowType);
+        validateHavingClause(select);
 
-        // Deduce which columns must be filtered.
-        ns.mustFilterFields = ImmutableBitSet.of();
-        if (from != null) {
-            final Set<SqlQualified> qualifieds = new LinkedHashSet<>();
-            for (ScopeChild child : fromScope.children) {
-                final List<String> fieldNames = child.namespace.getRowType().getFieldNames();
-                child.namespace
-                        .getMustFilterFields()
-                        .forEachInt(
-                                i ->
-                                        qualifieds.add(
-                                                SqlQualified.create(
-                                                        fromScope,
-                                                        1,
-                                                        child.namespace,
-                                                        new SqlIdentifier(
-                                                                ImmutableList.of(
-                                                                        child.name,
-                                                                        fieldNames.get(i)),
-                                                                SqlParserPos.ZERO))));
-            }
-            if (!qualifieds.isEmpty()) {
-                if (select.getWhere() != null) {
-                    forEachQualified(select.getWhere(), getWhereScope(select), qualifieds::remove);
-                }
-                if (select.getHaving() != null) {
-                    forEachQualified(
-                            select.getHaving(), getHavingScope(select), qualifieds::remove);
-                }
-
-                // Each of the must-filter fields identified must be returned as a
-                // SELECT item, which is then flagged as must-filter.
-                final BitSet mustFilterFields = new BitSet();
-                final List<SqlNode> expandedSelectItems =
-                        requireNonNull(fromScope.getExpandedSelectList(), "expandedSelectList");
-                forEach(
-                        expandedSelectItems,
-                        (selectItem, i) -> {
-                            selectItem = stripAs(selectItem);
-                            if (selectItem instanceof SqlIdentifier) {
-                                SqlQualified qualified =
-                                        fromScope.fullyQualify((SqlIdentifier) selectItem);
-                                if (qualifieds.remove(qualified)) {
-                                    // SELECT item #i referenced a must-filter column that was not
-                                    // filtered in the WHERE or HAVING. It becomes a must-filter
-                                    // column for our consumer.
-                                    mustFilterFields.set(i);
-                                }
-                            }
-                        });
-
-                // If there are must-filter fields that are not in the SELECT clause,
-                // this is an error.
-                if (!qualifieds.isEmpty()) {
-                    throw newValidationError(
-                            select,
-                            RESOURCE.mustFilterFieldsMissing(
-                                    qualifieds.stream()
-                                            .map(q -> q.suffix().get(0))
-                                            .collect(Collectors.toCollection(TreeSet::new))
-                                            .toString()));
-                }
-                ns.mustFilterFields = ImmutableBitSet.fromBitSet(mustFilterFields);
-            }
-        }
+        validateMustFilterRequirements(select, ns);
 
         // Validate ORDER BY after we have set ns.rowType because in some
         // dialects you can refer to columns of the select list, e.g.
@@ -4202,6 +4184,64 @@ public Void visit(SqlIdentifier id) {
                 });
     }
 
+    /**
+     * Removes all entries from {@code qualifieds} and {@code remnantMustFilterFields} if {@code
+     * node} is a bypassField.
+     */
+    private static void purgeForBypassFields(
+            SqlNode node,
+            SqlValidatorScope scope,
+            Set<SqlQualified> qualifieds,
+            Set<SqlQualified> bypassQualifieds,
+            Set<SqlQualified> remnantMustFilterFields) {
+        node.accept(
+                new SqlBasicVisitor<Void>() {
+                    @Override
+                    public Void visit(SqlIdentifier id) {
+                        final SqlQualified qualified = scope.fullyQualify(id);
+                        if (bypassQualifieds.contains(qualified)) {
+                            // Clear all the must-filter qualifieds from the same table identifier
+                            Collection<SqlQualified> sameIdentifier =
+                                    qualifieds.stream()
+                                            .filter(q -> qualifiedMatchesIdentifier(q, qualified))
+                                            .collect(Collectors.toList());
+                            sameIdentifier.forEach(qualifieds::remove);
+
+                            // Clear all the remnant must-filter qualifieds from the same table
+                            // identifier
+                            Collection<SqlQualified> sameIdentifier_ =
+                                    remnantMustFilterFields.stream()
+                                            .filter(q -> qualifiedMatchesIdentifier(q, qualified))
+                                            .collect(Collectors.toList());
+                            sameIdentifier_.forEach(remnantMustFilterFields::remove);
+                        }
+                        return null;
+                    }
+                });
+    }
+
+    private static void toQualifieds(
+            ImmutableBitSet fields,
+            Set<SqlQualified> qualifiedSet,
+            SelectScope fromScope,
+            ScopeChild child,
+            List<String> fieldNames) {
+        fields.forEachInt(
+                i ->
+                        qualifiedSet.add(
+                                SqlQualified.create(
+                                        fromScope,
+                                        1,
+                                        child.namespace,
+                                        new SqlIdentifier(
+                                                ImmutableList.of(child.name, fieldNames.get(i)),
+                                                SqlParserPos.ZERO))));
+    }
+
+    private static boolean qualifiedMatchesIdentifier(SqlQualified q1, SqlQualified q2) {
+        return q1.identifier.names.get(0).equals(q2.identifier.names.get(0));
+    }
+
     private void checkRollUpInSelectList(SqlSelect select) {
         SqlValidatorScope scope = getSelectScope(select);
         for (SqlNode item : SqlNonNullableAccessors.getSelectList(select)) {
@@ -4283,8 +4323,10 @@ private void checkRollUp(
                 // can be another SqlCall, or an SqlIdentifier.
                 checkRollUp(grandParent, parent, stripDot, scope, contextClause);
             } else if (stripDot.getKind() == SqlKind.CONVERT
-                    || stripDot.getKind() == SqlKind.TRANSLATE) {
-                // only need to check operand[0] for CONVERT or TRANSLATE
+                    || stripDot.getKind() == SqlKind.TRANSLATE
+                    || stripDot.getKind() == SqlKind.CONVERT_ORACLE) {
+                // only need to check operand[0] for
+                // CONVERT, TRANSLATE or CONVERT_ORACLE
                 SqlNode child = ((SqlCall) stripDot).getOperandList().get(0);
                 checkRollUp(parent, current, child, scope, contextClause);
             } else if (stripDot.getKind() == SqlKind.LAMBDA) {
@@ -4435,6 +4477,16 @@ private void validateModality(SqlNode query) {
                 default:
                     break;
             }
+        } else if (query.getKind() == SqlKind.WITH) {
+            // The modality of WITH clause depends on its body
+            // For example:
+            // SQL: WITH STREAMTABLE AS (SELECT STREAM * FROM KAFKA.MOCKTABLE) SELECT * FROM
+            // STREAMTABLE
+            // The modality should be RELATION.
+            // SQL: WITH STREAMTABLE AS (SELECT STREAM * FROM KAFKA.MOCKTABLE)
+            //      SELECT STREAM * FROM STREAMTABLE
+            // The modality should be STREAM.
+            validateModality(((SqlWith) query).body);
         } else {
             assert query.isA(SqlKind.SET_QUERY);
             final SqlCall call = (SqlCall) query;
@@ -4457,6 +4509,8 @@ private static SqlModality deduceModality(SqlNode query) {
                     : SqlModality.RELATION;
         } else if (query.getKind() == SqlKind.VALUES) {
             return SqlModality.RELATION;
+        } else if (query.getKind() == SqlKind.WITH) {
+            return deduceModality(((SqlWith) query).body);
         } else {
             assert query.isA(SqlKind.SET_QUERY);
             final SqlCall call = (SqlCall) query;
@@ -4666,6 +4720,106 @@ protected void validateQualifyClause(SqlSelect select) {
         }
     }
 
+    protected void validateMustFilterRequirements(SqlSelect select, SelectNamespace ns) {
+        ns.filterRequirement = FilterRequirement.EMPTY;
+        if (select.getFrom() != null) {
+            final SelectScope fromScope = (SelectScope) getFromScope(select);
+            final BitSet projectedNonFilteredBypassField = new BitSet();
+            final Set<SqlQualified> qualifieds = new LinkedHashSet<>();
+            final Set<SqlQualified> bypassQualifieds = new LinkedHashSet<>();
+            final Set<SqlQualified> remnantQualifieds = new LinkedHashSet<>();
+            for (ScopeChild child : fromScope.children) {
+                final List<String> fieldNames = child.namespace.getRowType().getFieldNames();
+                final FilterRequirement filterRequirement = child.namespace.getFilterRequirement();
+                toQualifieds(
+                        filterRequirement.filterFields, qualifieds, fromScope, child, fieldNames);
+                toQualifieds(
+                        filterRequirement.bypassFields,
+                        bypassQualifieds,
+                        fromScope,
+                        child,
+                        fieldNames);
+                remnantQualifieds.addAll(filterRequirement.remnantFilterFields);
+            }
+            if (!qualifieds.isEmpty() || !bypassQualifieds.isEmpty()) {
+                if (select.getWhere() != null) {
+                    forEachQualified(select.getWhere(), getWhereScope(select), qualifieds::remove);
+                    purgeForBypassFields(
+                            select.getWhere(),
+                            getWhereScope(select),
+                            qualifieds,
+                            bypassQualifieds,
+                            remnantQualifieds);
+                }
+                if (select.getHaving() != null) {
+                    forEachQualified(
+                            select.getHaving(), getHavingScope(select), qualifieds::remove);
+                    purgeForBypassFields(
+                            select.getHaving(),
+                            getHavingScope(select),
+                            qualifieds,
+                            bypassQualifieds,
+                            remnantQualifieds);
+                }
+
+                // Each of the must-filter fields identified must be returned as a
+                // SELECT item, which is then flagged as must-filter.
+                final BitSet mustFilterFields = new BitSet();
+                // Each of the bypass fields identified must be returned as a
+                // SELECT item, which is then flagged as a bypass field for the consumer.
+                final BitSet mustFilterBypassFields = new BitSet();
+                final List<SqlNode> expandedSelectItems =
+                        requireNonNull(fromScope.getExpandedSelectList(), "expandedSelectList");
+                forEach(
+                        expandedSelectItems,
+                        (selectItem, i) -> {
+                            selectItem = stripAs(selectItem);
+                            if (selectItem instanceof SqlIdentifier) {
+                                SqlQualified qualified =
+                                        fromScope.fullyQualify((SqlIdentifier) selectItem);
+                                if (qualifieds.remove(qualified)) {
+                                    // SELECT item #i referenced a must-filter column that was not
+                                    // filtered in the WHERE or HAVING. It becomes a must-filter
+                                    // column for our consumer.
+                                    mustFilterFields.set(i);
+                                }
+                                if (bypassQualifieds.remove(qualified)) {
+                                    // SELECT item #i referenced a bypass column that was not
+                                    // filtered
+                                    // in the WHERE or HAVING. It becomes a bypass column for our
+                                    // consumer.
+                                    mustFilterBypassFields.set(i);
+                                    projectedNonFilteredBypassField.set(0);
+                                }
+                            }
+                        });
+
+                // If there are must-filter fields that are not in the SELECT clause and
+                // there were no bypass-fields on this table, this is an error.
+                if (!qualifieds.isEmpty() && !projectedNonFilteredBypassField.get(0)) {
+                    throw newValidationError(
+                            select,
+                            RESOURCE.mustFilterFieldsMissing(
+                                    qualifieds.stream()
+                                            .map(q -> q.suffix().get(0))
+                                            .collect(Collectors.toCollection(TreeSet::new))
+                                            .toString()));
+                }
+                // Remaining must-filter fields can be defused by a bypass-field,
+                // so we pass this to the consumer.
+                ImmutableSet<SqlQualified> remnantMustFilterFields =
+                        Stream.of(remnantQualifieds, qualifieds)
+                                .flatMap(Set::stream)
+                                .collect(ImmutableSet.toImmutableSet());
+                ns.filterRequirement =
+                        new FilterRequirement(
+                                ImmutableBitSet.fromBitSet(mustFilterFields),
+                                ImmutableBitSet.fromBitSet(mustFilterBypassFields),
+                                remnantMustFilterFields);
+            }
+        }
+    }
+
     @Override
     public void validateWith(SqlWith with, SqlValidatorScope scope) {
         final SqlValidatorNamespace namespace = getNamespaceOrThrow(with);
@@ -5003,8 +5157,8 @@ protected void validateHavingClause(SqlSelect select) {
         if (SqlUtil.containsCall(having, call -> call.getOperator() instanceof SqlOverOperator)) {
             throw newValidationError(originalHaving, RESOURCE.windowInHavingNotAllowed());
         }
-        havingScope.checkAggregateExpr(having, true);
         inferUnknownTypes(booleanType, havingScope, having);
+        havingScope.checkAggregateExpr(having, true);
         having.validate(this, havingScope);
         final RelDataType type = deriveType(havingScope, having);
         if (!SqlTypeUtil.inBooleanFamily(type)) {
@@ -7117,17 +7271,15 @@ public RelDataType visit(SqlIdentifier id) {
                 if (field == null) {
                     throw newValidationError(id.getComponent(i), RESOURCE.unknownField(name));
                 }
-                // ----- FLINK MODIFICATION BEGIN -----
-                // Backport from Calcite (CALCITE-6764): if the parent record is
-                // nullable, the field must also be nullable.
                 boolean recordIsNullable = type.isNullable();
                 type = field.getType();
                 if (recordIsNullable) {
-                    type =
-                            ((RelDataTypeFactoryImpl) getTypeFactory())
-                                    .enforceTypeWithNullability(type, true);
+                    // If parent record is nullable, field must also be nullable.
+                    // Consider CREATE TABLE T(p ROW(k VARCHAR) NULL);
+                    // Since T.p is nullable, T.p.k also has to be nullable, even if
+                    // the type of k itself is not nullable.
+                    type = getTypeFactory().enforceTypeWithNullability(type, true);
                 }
-                // ----- FLINK MODIFICATION END -----
             }
             type = SqlTypeUtil.addCharsetAndCollation(type, getTypeFactory());
             return type;
@@ -7353,6 +7505,8 @@ static class ExtendedExpander extends Expander {
         final SqlSelect select;
         final SqlNode root;
         final Clause clause;
+        // Retain only expandable aliases or ordinals to prevent their expansion in a SQL call expr.
+        final Set<SqlNode> aliasOrdinalExpandSet = Sets.newIdentityHashSet();
 
         ExtendedExpander(
                 SqlValidatorImpl validator,
@@ -7364,6 +7518,9 @@ static class ExtendedExpander extends Expander {
             this.select = select;
             this.root = root;
             this.clause = clause;
+            if (clause == Clause.GROUP_BY) {
+                addExpandableExpressions();
+            }
         }
 
         @Override
@@ -7373,7 +7530,8 @@ static class ExtendedExpander extends Expander {
             }
 
             final boolean replaceAliases = clause.shouldReplaceAliases(validator.config);
-            if (!replaceAliases) {
+            if (!replaceAliases
+                    || (clause == Clause.GROUP_BY && !aliasOrdinalExpandSet.contains(id))) {
                 final SelectScope scope = validator.getRawSelectScopeNonNull(select);
                 SqlNode node = expandCommonColumn(select, id, scope, validator);
                 if (node != id) {
@@ -7422,24 +7580,7 @@ static class ExtendedExpander extends Expander {
             if (clause != Clause.GROUP_BY || !validator.config().conformance().isGroupByOrdinal()) {
                 return super.visit(literal);
             }
-            boolean isOrdinalLiteral = literal == root;
-            switch (root.getKind()) {
-                case GROUPING_SETS:
-                case ROLLUP:
-                case CUBE:
-                    if (root instanceof SqlBasicCall) {
-                        List<SqlNode> operandList = ((SqlBasicCall) root).getOperandList();
-                        for (SqlNode node : operandList) {
-                            if (node.equals(literal)) {
-                                isOrdinalLiteral = true;
-                                break;
-                            }
-                        }
-                    }
-                    break;
-                default:
-                    break;
-            }
+            boolean isOrdinalLiteral = aliasOrdinalExpandSet.contains(literal);
             if (isOrdinalLiteral) {
                 switch (literal.getTypeName()) {
                     case DECIMAL:
@@ -7468,6 +7609,49 @@ static class ExtendedExpander extends Expander {
             return super.visit(literal);
         }
 
+        /**
+         * Add all possible expandable 'group by' expression to set, which is used to check whether
+         * expr could be expanded as alias or ordinal.
+         */
+        @RequiresNonNull({"root"})
+        private void addExpandableExpressions() {
+            switch (root.getKind()) {
+                case IDENTIFIER:
+                case LITERAL:
+                    aliasOrdinalExpandSet.add(root);
+                    break;
+                case GROUPING_SETS:
+                case ROLLUP:
+                case CUBE:
+                    if (root instanceof SqlBasicCall) {
+                        List<SqlNode> operandList = ((SqlBasicCall) root).getOperandList();
+                        for (SqlNode sqlNode : operandList) {
+                            addIdentifierOrdinal2ExpandSet(sqlNode);
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        /**
+         * Identifier or literal in grouping sets, rollup, cube will be eligible for alias.
+         *
+         * @param sqlNode expression within grouping sets, rollup, cube
+         */
+        private void addIdentifierOrdinal2ExpandSet(SqlNode sqlNode) {
+            if (sqlNode.getKind() == SqlKind.ROW) {
+                List<SqlNode> rowOperandList = ((SqlCall) sqlNode).getOperandList();
+                for (SqlNode node : rowOperandList) {
+                    addIdentifierOrdinal2ExpandSet(node);
+                }
+            } else if (sqlNode.getKind() == SqlKind.IDENTIFIER
+                    || sqlNode.getKind() == SqlKind.LITERAL) {
+                aliasOrdinalExpandSet.add(sqlNode);
+            }
+        }
+
         /**
          * Returns whether a given node contains a {@link SqlIdentifier}.
          *
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/AggConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/AggConverter.java
index 5cd0848922237..7631bd9dbb554 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/AggConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/AggConverter.java
@@ -605,7 +605,7 @@ private int lookupOrCreateGroupExpr(RexNode expr) {
 
     /**
      * If an expression is structurally identical to one of the group-by expressions, returns a
-     * reference to the expression, otherwise returns null.
+     * reference to the expression, otherwise returns -1.
      */
     int lookupGroupExpr(SqlNode expr) {
         return SqlUtil.indexOfDeep(groupExprs, expr, Litmus.IGNORE);
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
index e3237b4b42aad..598849deb9b52 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
@@ -18,6 +18,7 @@
 
 import org.apache.flink.table.planner.plan.rules.logical.FlinkFilterProjectTransposeRule;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedMap;
@@ -42,6 +43,7 @@
 import org.apache.calcite.plan.hep.HepRelVertex;
 import org.apache.calcite.rel.BiRel;
 import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelFieldCollation;
 import org.apache.calcite.rel.RelHomogeneousShuttle;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.core.Aggregate;
@@ -83,6 +85,7 @@
 import org.apache.calcite.rex.RexUtil;
 import org.apache.calcite.rex.RexVisitorImpl;
 import org.apache.calcite.runtime.PairList;
+import org.apache.calcite.sql.SqlAggFunction;
 import org.apache.calcite.sql.SqlExplainFormat;
 import org.apache.calcite.sql.SqlExplainLevel;
 import org.apache.calcite.sql.SqlFunction;
@@ -93,6 +96,7 @@
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.tools.RelBuilderFactory;
+import org.apache.calcite.tools.RuleSet;
 import org.apache.calcite.util.Holder;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.Litmus;
@@ -195,6 +199,23 @@ public static RelNode decorrelateQuery(RelNode rootRel) {
      *     removed
      */
     public static RelNode decorrelateQuery(RelNode rootRel, RelBuilder relBuilder) {
+        return decorrelateQuery(rootRel, relBuilder, null);
+    }
+
+    /**
+     * Decorrelates a query specifying a set of rules to be used in the "remove correlation via
+     * rules" pre-processing.
+     *
+     * @param rootRel Root node of the query
+     * @param relBuilder Builder for relational expressions
+     * @param decorrelationRules Rules to be used in the decorrelation, if <code>null</code> a
+     *     default rule set will be used
+     * @return Equivalent query with all {@link org.apache.calcite.rel.core.Correlate} instances
+     *     removed
+     * @see #removeCorrelationViaRule(RelNode, RuleSet)
+     */
+    public static RelNode decorrelateQuery(
+            RelNode rootRel, RelBuilder relBuilder, @Nullable RuleSet decorrelationRules) {
         final CorelMap corelMap = new CorelMapBuilder().build(rootRel);
         if (!corelMap.hasCorrelation()) {
             return rootRel;
@@ -204,7 +225,10 @@ public static RelNode decorrelateQuery(RelNode rootRel, RelBuilder relBuilder) {
         final RelDecorrelator decorrelator =
                 new RelDecorrelator(corelMap, cluster.getPlanner().getContext(), relBuilder);
 
-        RelNode newRootRel = decorrelator.removeCorrelationViaRule(rootRel);
+        RelNode newRootRel =
+                decorrelationRules == null
+                        ? decorrelator.removeCorrelationViaRule(rootRel)
+                        : decorrelator.removeCorrelationViaRule(rootRel, decorrelationRules);
 
         if (SQL2REL_LOGGER.isDebugEnabled()) {
             SQL2REL_LOGGER.debug(
@@ -248,9 +272,13 @@ protected RelNode decorrelate(RelNode root) {
         HepProgram program =
                 HepProgram.builder()
                         .addRuleInstance(
-                                AdjustProjectForCountAggregateRule.config(false, this, f).toRule())
+                                AdjustProjectForCountAggregateRule.DEFAULT_WITHOUT_FAVLOR
+                                        .withRelBuilderFactory(f)
+                                        .toRule())
                         .addRuleInstance(
-                                AdjustProjectForCountAggregateRule.config(true, this, f).toRule())
+                                AdjustProjectForCountAggregateRule.DEFAULT_WITH_FAVLOR
+                                        .withRelBuilderFactory(f)
+                                        .toRule())
                         .addRuleInstance(
                                 FilterJoinRule.FilterIntoJoinRule.FilterIntoJoinRuleConfig.DEFAULT
                                         .withRelBuilderFactory(f)
@@ -378,22 +406,54 @@ protected RelNode decorrelate(RelNode root) {
     private HepPlanner createPlanner(HepProgram program) {
         // Create a planner with a hook to update the mapping tables when a
         // node is copied when it is registered.
-        return new HepPlanner(program, context, true, createCopyHook(), RelOptCostImpl.FACTORY);
+        HepPlanner planner =
+                new HepPlanner(program, context, true, createCopyHook(), RelOptCostImpl.FACTORY);
+        planner.setDecorrelator(this);
+        return planner;
     }
 
+    /**
+     * Remove some instances of {@link org.apache.calcite.rel.core.Correlate} from a query plan by
+     * applying a default set of rules (only some of the {@link
+     * org.apache.calcite.rel.core.Correlate}s might be removable in such way).
+     */
     public RelNode removeCorrelationViaRule(RelNode root) {
         final RelBuilderFactory f = relBuilderFactory();
         HepProgram program =
                 HepProgram.builder()
-                        .addRuleInstance(RemoveSingleAggregateRule.config(f).toRule())
+                        .addRuleInstance(RemoveSingleAggregateRule.DEFAULT.toRule())
                         .addRuleInstance(
-                                RemoveCorrelationForScalarProjectRule.config(this, f).toRule())
+                                RemoveCorrelationForScalarProjectRule.DEFAULT
+                                        .withRelBuilderFactory(f)
+                                        .toRule())
                         .addRuleInstance(
-                                RemoveCorrelationForScalarAggregateRule.config(this, f).toRule())
+                                RemoveCorrelationForScalarAggregateRule.DEFAULT
+                                        .withRelBuilderFactory(f)
+                                        .toRule())
                         .build();
+        return removeCorrelationViaRule(root, program);
+    }
 
-        HepPlanner planner = createPlanner(program);
+    /**
+     * Remove some instances of {@link org.apache.calcite.rel.core.Correlate} from a query plan by
+     * applying a certain {@link RuleSet} (only some of the {@link
+     * org.apache.calcite.rel.core.Correlate}s might be removable in such way).
+     */
+    public RelNode removeCorrelationViaRule(RelNode root, RuleSet ruleSet) {
+        final RelBuilderFactory f = relBuilderFactory();
+        final HepProgramBuilder builder = HepProgram.builder();
+        for (RelOptRule rule : ruleSet) {
+            if (rule instanceof RelRule) {
+                rule = ((RelRule<?>) rule).config.withRelBuilderFactory(f).toRule();
+            }
+            builder.addRuleInstance(rule);
+        }
+        final HepProgram program = builder.build();
+        return removeCorrelationViaRule(root, program);
+    }
 
+    private RelNode removeCorrelationViaRule(RelNode root, HepProgram program) {
+        HepPlanner planner = createPlanner(program);
         planner.setRoot(root);
         return planner.findBestExp();
     }
@@ -497,6 +557,17 @@ protected RexNode removeCorrelationExpr(
             return null;
         }
 
+        if (isCorVarDefined && (rel.fetch != null || rel.offset != null)) {
+            if (rel.fetch != null && rel.offset == null && RexLiteral.intValue(rel.fetch) == 1) {
+                return decorrelateFetchOneSort(rel, frame);
+            }
+            // Can not decorrelate if the sort has per-correlate-key attributes like
+            // offset or fetch limit, because these attributes scope would change to
+            // global after decorrelation. They should take effect within the scope
+            // of the correlation key actually.
+            return null;
+        }
+
         final RelNode newInput = frame.r;
 
         Mappings.TargetMapping mapping =
@@ -748,16 +819,6 @@ private static void shiftMapping(Map<Integer, Integer> mapping, int startIndex,
     public @Nullable Frame getInvoke(RelNode r, boolean isCorVarDefined, @Nullable RelNode parent) {
         final Frame frame = dispatcher.invoke(r, isCorVarDefined);
         currentRel = parent;
-        if (frame != null && isCorVarDefined && r instanceof Sort) {
-            final Sort sort = (Sort) r;
-            // Can not decorrelate if the sort has per-correlate-key attributes like
-            // offset or fetch limit, because these attributes scope would change to
-            // global after decorrelation. They should take effect within the scope
-            // of the correlation key actually.
-            if (sort.offset != null || sort.fetch != null) {
-                return null;
-            }
-        }
         if (frame != null) {
             map.put(r, frame);
         }
@@ -776,6 +837,153 @@ private static void shiftMapping(Map<Integer, Integer> mapping, int startIndex,
         return null;
     }
 
+    protected @Nullable Frame decorrelateFetchOneSort(Sort sort, final Frame frame) {
+        Frame aggFrame = decorrelateSortAsAggregate(sort, frame);
+        if (aggFrame != null) {
+            return aggFrame;
+        }
+        //
+        // Rewrite logic:
+        //
+        // If sorted without offset and fetch = 1 (enforced by the caller), rewrite the sort to be
+        //   Aggregate(group=(corVar.. , field..))
+        //     project(first_value(field) over (partition by corVar order by (sort collation)))
+        //       input
+        //
+        // 1. For the original sorted input, apply the FIRST_VALUE window function to produce
+        //    the result of sorting with LIMIT 1, and the same as the decorrelate of aggregate,
+        //    add correlated variables in partition list to maintain semantic consistency.
+        // 2. To ensure that there is at most one row of output for
+        //    any combination of correlated variables, distinct for correlated variables.
+        // 3. Since we have partitioned by all correlated variables
+        //    in the sorted output field window, so for any combination of correlated variables,
+        //    all other field values are unique. So the following two are equivalent:
+        //      - group by corVar1, covVar2, field1, field2
+        //      - any_value(fields1), any_value(fields2) group by corVar1, covVar2
+        //    Here we use the first.
+        final Map<Integer, Integer> mapOldToNewOutputs = new HashMap<>();
+        final NavigableMap<CorDef, Integer> corDefOutputs = new TreeMap<>();
+
+        final PairList<RexNode, String> corVarProjects = PairList.of();
+        List<RelDataTypeField> fieldList = frame.r.getRowType().getFieldList();
+        for (Map.Entry<CorDef, Integer> entry : frame.corDefOutputs.entrySet()) {
+            corDefOutputs.put(
+                    entry.getKey(), sort.getRowType().getFieldCount() + corVarProjects.size());
+            RexInputRef.add2(corVarProjects, entry.getValue(), fieldList);
+        }
+
+        final List<RexNode> sortExprs =
+                new ArrayList<>(sort.getCollation().getFieldCollations().size());
+        for (RelFieldCollation collation : sort.getCollation().getFieldCollations()) {
+            Integer newIdx = requireNonNull(frame.oldToNewOutputs.get(collation.getFieldIndex()));
+            RexNode node = RexInputRef.of(newIdx, fieldList);
+            if (collation.direction == RelFieldCollation.Direction.DESCENDING) {
+                node = relBuilder.desc(node);
+            }
+            if (collation.nullDirection == RelFieldCollation.NullDirection.FIRST) {
+                node = relBuilder.nullsFirst(node);
+            } else if (collation.nullDirection == RelFieldCollation.NullDirection.LAST) {
+                node = relBuilder.nullsLast(node);
+            }
+            sortExprs.add(node);
+        }
+
+        final PairList<RexNode, String> newProjExprs = PairList.of();
+        for (RelDataTypeField field : sort.getRowType().getFieldList()) {
+            final int newIdx = requireNonNull(frame.oldToNewOutputs.get(field.getIndex()));
+
+            RelBuilder.AggCall aggCall =
+                    relBuilder.aggregateCall(
+                            SqlStdOperatorTable.FIRST_VALUE, RexInputRef.of(newIdx, fieldList));
+
+            // Convert each field from the sorted output to a window function that partitions by
+            // correlated variables, orders by the collation, and return the first_value.
+            RexNode winCall =
+                    aggCall.over()
+                            .orderBy(sortExprs)
+                            .partitionBy(corVarProjects.leftList())
+                            .toRex();
+            mapOldToNewOutputs.put(newProjExprs.size(), newProjExprs.size());
+            newProjExprs.add(winCall, field.getName());
+        }
+        newProjExprs.addAll(corVarProjects);
+        RelNode result =
+                relBuilder
+                        .push(frame.r)
+                        .project(newProjExprs.leftList(), newProjExprs.rightList())
+                        .distinct()
+                        .build();
+
+        return register(sort, result, mapOldToNewOutputs, corDefOutputs);
+    }
+
+    protected @Nullable Frame decorrelateSortAsAggregate(Sort sort, final Frame frame) {
+        final Map<Integer, Integer> mapOldToNewOutputs = new HashMap<>();
+        final NavigableMap<CorDef, Integer> corDefOutputs = new TreeMap<>();
+        if (sort.getCollation().getFieldCollations().size() == 1
+                && sort.getRowType().getFieldCount() == 1
+                && !frame.corDefOutputs.isEmpty()) {
+            //
+            // Rewrite logic:
+            //
+            // If sorted with no OFFSET and FETCH = 1, and only one collation field,
+            // rewrite the Sort as Aggregate using MIN/MAX function.
+            // Example:
+            //  Sort(sort0=[$0], dir0=[ASC], fetch=[1])
+            //   input
+            // Rewrite to:
+            //  Aggregate(group=(corVar), agg=[min($0))
+            //
+            // Note: MIN/MAX is not strictly equivalent to LIMIT 1. When the input has 0 rows,
+            // MIN/MAX returns NULL, while LIMIT 1 returns 0 rows.
+            // However, in the decorrelate, we add correlated variables to the group list
+            // to ensure equivalence when Correlate is transformed to Join. When the group list
+            // is non-empty, MIN/MAX will also return 0 rows if the input has 0 rows.
+            // So in this case, the transformation is legal.
+            RelFieldCollation collation = Util.first(sort.getCollation().getFieldCollations());
+
+            if (collation.nullDirection != RelFieldCollation.NullDirection.LAST) {
+                return null;
+            }
+
+            SqlAggFunction aggFunction;
+            switch (collation.getDirection()) {
+                case ASCENDING:
+                case STRICTLY_ASCENDING:
+                    aggFunction = SqlStdOperatorTable.MIN;
+                    break;
+                case DESCENDING:
+                case STRICTLY_DESCENDING:
+                    aggFunction = SqlStdOperatorTable.MAX;
+                    break;
+                default:
+                    return null;
+            }
+
+            final int newIdx = requireNonNull(frame.oldToNewOutputs.get(collation.getFieldIndex()));
+            RelBuilder.AggCall aggCall =
+                    relBuilder
+                            .push(frame.r)
+                            .aggregateCall(
+                                    aggFunction, relBuilder.fields(ImmutableList.of(newIdx)));
+
+            // As with the aggregate decorrelate, add correlated variables to the group list.
+            final List<RexInputRef> groupKey = new ArrayList<>();
+            for (Map.Entry<CorDef, Integer> entry : frame.corDefOutputs.entrySet()) {
+                groupKey.add(RexInputRef.of(entry.getValue(), frame.r.getRowType()));
+                corDefOutputs.put(entry.getKey(), corDefOutputs.size());
+            }
+
+            RelNode aggregate =
+                    relBuilder.aggregate(relBuilder.groupKey(groupKey), aggCall).build();
+
+            // Add the mapping for the added aggregate fields.
+            mapOldToNewOutputs.put(0, groupKey.size());
+            return register(sort, aggregate, mapOldToNewOutputs, corDefOutputs);
+        }
+        return null;
+    }
+
     public @Nullable Frame decorrelateRel(LogicalProject rel, boolean isCorVarDefined) {
         return decorrelateRel((Project) rel, isCorVarDefined);
     }
@@ -1910,23 +2118,22 @@ public RexNode visitCall(final RexCall call) {
      */
     public static final class RemoveSingleAggregateRule
             extends RelRule<RemoveSingleAggregateRule.RemoveSingleAggregateRuleConfig> {
-        static RemoveSingleAggregateRuleConfig config(RelBuilderFactory f) {
-            return ImmutableRemoveSingleAggregateRuleConfig.builder()
-                    .withRelBuilderFactory(f)
-                    .withOperandSupplier(
-                            b0 ->
-                                    b0.operand(Aggregate.class)
-                                            .oneInput(
-                                                    b1 ->
-                                                            b1.operand(Project.class)
-                                                                    .oneInput(
-                                                                            b2 ->
-                                                                                    b2.operand(
-                                                                                                    Aggregate
-                                                                                                            .class)
-                                                                                            .anyInputs())))
-                    .build();
-        }
+
+        static final RemoveSingleAggregateRuleConfig DEFAULT =
+                ImmutableRemoveSingleAggregateRuleConfig.builder()
+                        .withOperandSupplier(
+                                b0 ->
+                                        b0.operand(Aggregate.class)
+                                                .oneInput(
+                                                        b1 ->
+                                                                b1.operand(Project.class)
+                                                                        .oneInput(
+                                                                                b2 ->
+                                                                                        b2.operand(
+                                                                                                        Aggregate
+                                                                                                                .class)
+                                                                                                .anyInputs())))
+                        .build();
 
         /** Creates a RemoveSingleAggregateRule. */
         RemoveSingleAggregateRule(RemoveSingleAggregateRuleConfig config) {
@@ -1982,42 +2189,37 @@ public static final class RemoveCorrelationForScalarProjectRule
             extends RelRule<
                     RemoveCorrelationForScalarProjectRule
                             .RemoveCorrelationForScalarProjectRuleConfig> {
-        private final RelDecorrelator d;
-
-        static RemoveCorrelationForScalarProjectRuleConfig config(
-                RelDecorrelator decorrelator, RelBuilderFactory relBuilderFactory) {
-            return ImmutableRemoveCorrelationForScalarProjectRuleConfig.builder()
-                    .withRelBuilderFactory(relBuilderFactory)
-                    .withOperandSupplier(
-                            b0 ->
-                                    b0.operand(Correlate.class)
-                                            .inputs(
-                                                    b1 -> b1.operand(RelNode.class).anyInputs(),
-                                                    b2 ->
-                                                            b2.operand(Aggregate.class)
-                                                                    .oneInput(
-                                                                            b3 ->
-                                                                                    b3.operand(
-                                                                                                    Project
-                                                                                                            .class)
-                                                                                            .oneInput(
-                                                                                                    b4 ->
-                                                                                                            b4.operand(
-                                                                                                                            RelNode
-                                                                                                                                    .class)
-                                                                                                                    .anyInputs()))))
-                    .withDecorrelator(decorrelator)
-                    .build();
-        }
+
+        static final RemoveCorrelationForScalarProjectRuleConfig DEFAULT =
+                ImmutableRemoveCorrelationForScalarProjectRuleConfig.builder()
+                        .withOperandSupplier(
+                                b0 ->
+                                        b0.operand(Correlate.class)
+                                                .inputs(
+                                                        b1 -> b1.operand(RelNode.class).anyInputs(),
+                                                        b2 ->
+                                                                b2.operand(Aggregate.class)
+                                                                        .oneInput(
+                                                                                b3 ->
+                                                                                        b3.operand(
+                                                                                                        Project
+                                                                                                                .class)
+                                                                                                .oneInput(
+                                                                                                        b4 ->
+                                                                                                                b4.operand(
+                                                                                                                                RelNode
+                                                                                                                                        .class)
+                                                                                                                        .anyInputs()))))
+                        .build();
 
         /** Creates a RemoveCorrelationForScalarProjectRule. */
         RemoveCorrelationForScalarProjectRule(RemoveCorrelationForScalarProjectRuleConfig config) {
             super(config);
-            this.d = requireNonNull(config.decorrelator());
         }
 
         @Override
         public void onMatch(RelOptRuleCall call) {
+            final RelDecorrelator d = call.getPlanner().getDecorrelator();
             final Correlate correlate = call.rel(0);
             final RelNode left = call.rel(1);
             final Aggregate aggregate = call.rel(2);
@@ -2187,14 +2389,9 @@ public void onMatch(RelOptRuleCall call) {
             d.removeCorVarFromTree(correlate);
         }
 
-        /**
-         * Rule configuration.
-         *
-         * <p>Extends {@link RelDecorrelator.Config} because rule needs a decorrelator instance.
-         */
+        /** Rule configuration. */
         @Value.Immutable(singleton = false)
-        public interface RemoveCorrelationForScalarProjectRuleConfig
-                extends RelDecorrelator.Config {
+        public interface RemoveCorrelationForScalarProjectRuleConfig extends RelRule.Config {
             @Override
             default RemoveCorrelationForScalarProjectRule toRule() {
                 return new RemoveCorrelationForScalarProjectRule(this);
@@ -2207,51 +2404,46 @@ public static final class RemoveCorrelationForScalarAggregateRule
             extends RelRule<
                     RemoveCorrelationForScalarAggregateRule
                             .RemoveCorrelationForScalarAggregateRuleConfig> {
-        private final RelDecorrelator d;
-
-        static RemoveCorrelationForScalarAggregateRuleConfig config(
-                RelDecorrelator d, RelBuilderFactory relBuilderFactory) {
-            return ImmutableRemoveCorrelationForScalarAggregateRuleConfig.builder()
-                    .withRelBuilderFactory(relBuilderFactory)
-                    .withOperandSupplier(
-                            b0 ->
-                                    b0.operand(Correlate.class)
-                                            .inputs(
-                                                    b1 -> b1.operand(RelNode.class).anyInputs(),
-                                                    b2 ->
-                                                            b2.operand(Project.class)
-                                                                    .oneInput(
-                                                                            b3 ->
-                                                                                    b3.operand(
-                                                                                                    Aggregate
-                                                                                                            .class)
-                                                                                            .predicate(
-                                                                                                    Aggregate
-                                                                                                            ::isSimple)
-                                                                                            .oneInput(
-                                                                                                    b4 ->
-                                                                                                            b4.operand(
-                                                                                                                            Project
-                                                                                                                                    .class)
-                                                                                                                    .oneInput(
-                                                                                                                            b5 ->
-                                                                                                                                    b5.operand(
-                                                                                                                                                    RelNode
-                                                                                                                                                            .class)
-                                                                                                                                            .anyInputs())))))
-                    .withDecorrelator(d)
-                    .build();
-        }
+
+        static final RemoveCorrelationForScalarAggregateRuleConfig DEFAULT =
+                ImmutableRemoveCorrelationForScalarAggregateRuleConfig.builder()
+                        .withOperandSupplier(
+                                b0 ->
+                                        b0.operand(Correlate.class)
+                                                .inputs(
+                                                        b1 -> b1.operand(RelNode.class).anyInputs(),
+                                                        b2 ->
+                                                                b2.operand(Project.class)
+                                                                        .oneInput(
+                                                                                b3 ->
+                                                                                        b3.operand(
+                                                                                                        Aggregate
+                                                                                                                .class)
+                                                                                                .predicate(
+                                                                                                        Aggregate
+                                                                                                                ::isSimple)
+                                                                                                .oneInput(
+                                                                                                        b4 ->
+                                                                                                                b4.operand(
+                                                                                                                                Project
+                                                                                                                                        .class)
+                                                                                                                        .oneInput(
+                                                                                                                                b5 ->
+                                                                                                                                        b5.operand(
+                                                                                                                                                        RelNode
+                                                                                                                                                                .class)
+                                                                                                                                                .anyInputs())))))
+                        .build();
 
         /** Creates a RemoveCorrelationForScalarAggregateRule. */
         RemoveCorrelationForScalarAggregateRule(
                 RemoveCorrelationForScalarAggregateRuleConfig config) {
             super(config);
-            d = requireNonNull(config.decorrelator());
         }
 
         @Override
         public void onMatch(RelOptRuleCall call) {
+            final RelDecorrelator d = call.getPlanner().getDecorrelator();
             final Correlate correlate = call.rel(0);
             final RelNode left = call.rel(1);
             final Project aggOutputProject = call.rel(2);
@@ -2584,14 +2776,9 @@ public void onMatch(RelOptRuleCall call) {
             d.removeCorVarFromTree(correlate);
         }
 
-        /**
-         * Rule configuration.
-         *
-         * <p>Extends {@link RelDecorrelator.Config} because rule needs a decorrelator instance.
-         */
+        /** Rule configuration. */
         @Value.Immutable(singleton = false)
-        public interface RemoveCorrelationForScalarAggregateRuleConfig
-                extends RelDecorrelator.Config {
+        public interface RemoveCorrelationForScalarAggregateRuleConfig extends RelRule.Config {
             @Override
             default RemoveCorrelationForScalarAggregateRule toRule() {
                 return new RemoveCorrelationForScalarAggregateRule(this);
@@ -2611,41 +2798,46 @@ default RemoveCorrelationForScalarAggregateRule toRule() {
     public static final class AdjustProjectForCountAggregateRule
             extends RelRule<
                     AdjustProjectForCountAggregateRule.AdjustProjectForCountAggregateRuleConfig> {
-        final RelDecorrelator d;
-
-        static AdjustProjectForCountAggregateRuleConfig config(
-                boolean flavor, RelDecorrelator decorrelator, RelBuilderFactory relBuilderFactory) {
-            return ImmutableAdjustProjectForCountAggregateRuleConfig.builder()
-                    .withRelBuilderFactory(relBuilderFactory)
-                    .withOperandSupplier(
-                            b0 ->
-                                    b0.operand(Correlate.class)
-                                            .inputs(
-                                                    b1 -> b1.operand(RelNode.class).anyInputs(),
-                                                    b2 ->
-                                                            flavor
-                                                                    ? b2.operand(Project.class)
-                                                                            .oneInput(
-                                                                                    b3 ->
-                                                                                            b3.operand(
-                                                                                                            Aggregate
-                                                                                                                    .class)
-                                                                                                    .anyInputs())
-                                                                    : b2.operand(Aggregate.class)
-                                                                            .anyInputs()))
-                    .withFlavor(flavor)
-                    .withDecorrelator(decorrelator)
-                    .build();
-        }
+
+        static final AdjustProjectForCountAggregateRuleConfig DEFAULT_WITH_FAVLOR =
+                ImmutableAdjustProjectForCountAggregateRuleConfig.builder()
+                        .withOperandSupplier(
+                                b0 ->
+                                        b0.operand(Correlate.class)
+                                                .inputs(
+                                                        b1 -> b1.operand(RelNode.class).anyInputs(),
+                                                        b2 ->
+                                                                b2.operand(Project.class)
+                                                                        .oneInput(
+                                                                                b3 ->
+                                                                                        b3.operand(
+                                                                                                        Aggregate
+                                                                                                                .class)
+                                                                                                .anyInputs())))
+                        .withFlavor(true)
+                        .build();
+
+        static final AdjustProjectForCountAggregateRuleConfig DEFAULT_WITHOUT_FAVLOR =
+                ImmutableAdjustProjectForCountAggregateRuleConfig.builder()
+                        .withOperandSupplier(
+                                b0 ->
+                                        b0.operand(Correlate.class)
+                                                .inputs(
+                                                        b1 -> b1.operand(RelNode.class).anyInputs(),
+                                                        b2 ->
+                                                                b2.operand(Aggregate.class)
+                                                                        .anyInputs()))
+                        .withFlavor(false)
+                        .build();
 
         /** Creates an AdjustProjectForCountAggregateRule. */
         AdjustProjectForCountAggregateRule(AdjustProjectForCountAggregateRuleConfig config) {
             super(config);
-            this.d = requireNonNull(config.decorrelator());
         }
 
         @Override
         public void onMatch(RelOptRuleCall call) {
+            final RelDecorrelator d = call.getPlanner().getDecorrelator();
             final Correlate correlate = call.rel(0);
             final RelNode left = call.rel(1);
             final Project aggOutputProject;
@@ -2668,10 +2860,11 @@ public void onMatch(RelOptRuleCall call) {
                         .projectNamed(projects.leftList(), projects.rightList(), true);
                 aggOutputProject = (Project) relBuilder.build();
             }
-            onMatch2(call, correlate, left, aggOutputProject, aggregate);
+            onMatch2(d, call, correlate, left, aggOutputProject, aggregate);
         }
 
         private void onMatch2(
+                RelDecorrelator d,
                 RelOptRuleCall call,
                 Correlate correlate,
                 RelNode leftInput,
@@ -2770,7 +2963,7 @@ private void onMatch2(
 
         /** Rule configuration. */
         @Value.Immutable(singleton = false)
-        public interface AdjustProjectForCountAggregateRuleConfig extends RelDecorrelator.Config {
+        public interface AdjustProjectForCountAggregateRuleConfig extends RelRule.Config {
             @Override
             default AdjustProjectForCountAggregateRule toRule() {
                 return new AdjustProjectForCountAggregateRule(this);
@@ -3094,15 +3287,6 @@ assert allLessThan(
         }
     }
 
-    /** Base configuration for rules that are non-static in a RelDecorrelator. */
-    public interface Config extends RelRule.Config {
-        /** Returns the RelDecorrelator that will be context for the created rule instance. */
-        RelDecorrelator decorrelator();
-
-        /** Sets {@link #decorrelator}. */
-        Config withDecorrelator(RelDecorrelator decorrelator);
-    }
-
     // -------------------------------------------------------------------------
     //  Getter/Setter
     // -------------------------------------------------------------------------
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
index d4d0dda74e70f..abb0e9a882312 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
@@ -79,11 +79,10 @@
 import org.apache.calcite.rel.logical.LogicalTableFunctionScan;
 import org.apache.calcite.rel.logical.LogicalTableModify;
 import org.apache.calcite.rel.logical.LogicalTableScan;
-import org.apache.calcite.rel.logical.LogicalUnion;
 import org.apache.calcite.rel.logical.LogicalValues;
 import org.apache.calcite.rel.metadata.RelColumnMapping;
+import org.apache.calcite.rel.metadata.RelMdUtil;
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
-import org.apache.calcite.rel.rel2sql.SqlImplementor;
 import org.apache.calcite.rel.stream.Delta;
 import org.apache.calcite.rel.stream.LogicalDelta;
 import org.apache.calcite.rel.type.RelDataType;
@@ -99,7 +98,6 @@
 import org.apache.calcite.rex.RexLambdaRef;
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
-import org.apache.calcite.rex.RexOver;
 import org.apache.calcite.rex.RexPatternFieldRef;
 import org.apache.calcite.rex.RexRangeRef;
 import org.apache.calcite.rex.RexShuttle;
@@ -238,7 +236,6 @@
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static java.util.Objects.requireNonNull;
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
-import static org.apache.calcite.runtime.FlatLists.append;
 import static org.apache.calcite.sql.SqlUtil.containsDefault;
 import static org.apache.calcite.sql.SqlUtil.containsIn;
 import static org.apache.calcite.sql.SqlUtil.stripAs;
@@ -249,7 +246,11 @@
 import static org.apache.calcite.sql.type.SqlTypeUtil.isExactNumeric;
 import static org.apache.calcite.sql.type.SqlTypeUtil.keepSourceTypeAndTargetNullability;
 import static org.apache.calcite.sql.type.SqlTypeUtil.promoteToRowType;
+import static org.apache.calcite.sql.validate.SqlValidatorUtil.addAlias;
 import static org.apache.calcite.util.Static.RESOURCE;
+import static org.apache.calcite.util.Util.first;
+import static org.apache.calcite.util.Util.last;
+import static org.apache.calcite.util.Util.skipLast;
 import static org.apache.calcite.util.Util.transform;
 
 /**
@@ -284,7 +285,6 @@
  *   <li>FLINK-37269
  * </ol>
  */
-@SuppressWarnings("UnstableApiUsage")
 @Value.Enclosing
 public class SqlToRelConverter {
     // ~ Static fields/initializers ---------------------------------------------
@@ -824,7 +824,7 @@ protected void convertSelectImpl(
         // Semantics example. Given the view definition
         //   CREATE VIEW v2 AS SELECT * FROM t ORDER BY x LIMIT 10
         // we would never remove the ORDER BY, because "ORDER BY ... LIMIT" is about
-        // semantics. It is not a 'pure order'.
+        // semantics. It is not a 'pure order'. Similarly "ORDER BY x OFFSET 5".
         if (RelOptUtil.isPureOrder(castNonNull(bb.root)) && config.isRemoveSortInSubQuery()) {
             // Remove the Sort if the view is at the top level. Also remove the Sort
             // if there are other nodes, which will cause the view to be in the
@@ -846,13 +846,8 @@ protected void convertSelectImpl(
         gatherOrderExprs(bb, select, select.getOrderList(), orderExprList, collationList);
         final RelCollation collation = cluster.traitSet().canonize(RelCollations.of(collationList));
 
-        if (validator().isAggregate(select)) {
-            convertAgg(bb, select, orderExprList);
-        } else {
-            convertSelectList(bb, measureBb, select, orderExprList);
-        }
-
-        convertQualify(bb, select.getQualify());
+        convertSelectList(
+                bb, measureBb, select, orderExprList, ImmutableList.of(), select.getQualify());
 
         if (select.isDistinct()) {
             distinctify(bb, true);
@@ -1211,23 +1206,14 @@ private void convertWhere(final Blackboard bb, final @Nullable SqlNode where) {
 
     private void replaceSubQueries(
             final Blackboard bb, final SqlNode expr, RelOptUtil.Logic logic) {
-        replaceSubQueries(bb, expr, logic, null);
-    }
-
-    private void replaceSubQueries(
-            final Blackboard bb,
-            final SqlNode expr,
-            RelOptUtil.Logic logic,
-            final SqlImplementor.Clause clause) {
-        findSubQueries(bb, expr, logic, false, clause);
+        findSubQueries(bb, expr, logic, false);
         for (SubQuery node : bb.subQueryList) {
             substituteSubQuery(bb, node);
         }
     }
 
     private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
-        final RexNode expr = subQuery.expr;
-        if (expr != null) {
+        if (subQuery.expr != null) {
             // Already done.
             return;
         }
@@ -1259,9 +1245,7 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
             case ALL:
                 call = (SqlBasicCall) subQuery.node;
                 query = call.operand(1);
-                if (!config.isExpand() && !(query instanceof SqlNodeList)) {
-                    return;
-                }
+
                 final SqlNode leftKeyNode = call.operand(0);
 
                 final List<SqlNode> leftSqlKeys;
@@ -1294,6 +1278,34 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
                     // reference to Q below.
                 }
 
+                final RelDataType targetRowType =
+                        promoteToRowType(
+                                typeFactory, validator().getValidatedNodeType(leftKeyNode), null);
+
+                if (!config.isExpand()) {
+                    if (query instanceof SqlNodeList) {
+                        // convert
+                        // select * from "scott".emp where sal > some (4000, 2000)
+                        // to
+                        // select * from "scott".emp where sal > some (VALUES (4000), (2000))
+                        // The SqlNodeList become a RexSubQuery then optimized by
+                        // SubQueryRemoveRule.
+                        RelNode relNode =
+                                convertRowValues(
+                                        bb, query, (SqlNodeList) query, false, targetRowType);
+                        final ImmutableList.Builder<RexNode> builder = ImmutableList.builder();
+                        for (SqlNode node : leftSqlKeys) {
+                            builder.add(bb.convertExpression(node));
+                        }
+                        final ImmutableList<RexNode> list = builder.build();
+                        assert relNode != null;
+                        subQuery.expr =
+                                createSubquery(subQuery.node.getKind(), relNode, list, call);
+                        return;
+                    }
+                    return;
+                }
+
                 final List<RexNode> leftKeys =
                         leftSqlKeys.stream().map(bb::convertExpression).collect(toImmutableList());
 
@@ -1330,9 +1342,7 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
                 if (bb.root == null) {
                     return;
                 }
-                final RelDataType targetRowType =
-                        promoteToRowType(
-                                typeFactory, validator().getValidatedNodeType(leftKeyNode), null);
+
                 final boolean notIn = call.getOperator().kind == SqlKind.NOT_IN;
                 converted =
                         convertExists(
@@ -1437,12 +1447,11 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
                 final Blackboard seekBb = createBlackboard(seekScope, null, false);
                 final RelNode seekRel = convertQueryOrInList(seekBb, query, null);
                 requireNonNull(seekRel, () -> "seekRel is null for query " + query);
-                // An EXIST sub-query whose inner child has at least 1 tuple
+                // An EXIST sub-query whose inner child guaranteed never empty
                 // (e.g. an Aggregate with no grouping columns or non-empty Values
                 // node) should be simplified to a Boolean constant expression.
                 final RelMetadataQuery mq = seekRel.getCluster().getMetadataQuery();
-                final Double minRowCount = mq.getMinRowCount(seekRel);
-                if (minRowCount != null && minRowCount >= 1D) {
+                if (RelMdUtil.isRelDefinitelyNotEmpty(mq, seekRel)) {
                     subQuery.expr = rexBuilder.makeLiteral(true);
                     return;
                 }
@@ -2037,7 +2046,7 @@ private RelOptUtil.Exists convertExists(
             if (!values.getTuples().isEmpty()) {
                 unionInputs.add(values);
             }
-            resultRel = LogicalUnion.create(unionInputs, true);
+            resultRel = relBuilder.pushAll(unionInputs).union(true, unionInputs.size()).build();
         }
         leaves.put(resultRel, resultRel.getRowType().getFieldCount());
         return resultRel;
@@ -2113,14 +2122,17 @@ private static boolean isRowConstructor(SqlNode node) {
      *     FALSE)
      * @param registerOnlyScalarSubQueries if set to true and the parse tree corresponds to a
      *     variation of a select node, only register it if it's a scalar sub-query
-     * @param clause A clause inside which sub-query is searched
      */
     private void findSubQueries(
             Blackboard bb,
             SqlNode node,
             RelOptUtil.Logic logic,
-            boolean registerOnlyScalarSubQueries,
-            SqlImplementor.Clause clause) {
+            boolean registerOnlyScalarSubQueries) {
+        // If node is structurally identical to one of the group-by,
+        // then it is not a sub-query; it is a reference.
+        if (bb.agg != null && bb.agg.lookupGroupExpr(node) != -1) {
+            return;
+        }
         final SqlKind kind = node.getKind();
         switch (kind) {
             case EXISTS:
@@ -2134,7 +2146,7 @@ private void findSubQueries(
             case SET_SEMANTICS_TABLE:
             case SCALAR_QUERY:
                 if (!registerOnlyScalarSubQueries || (kind == SqlKind.SCALAR_QUERY)) {
-                    bb.registerSubQuery(node, RelOptUtil.Logic.TRUE_FALSE, clause);
+                    bb.registerSubQuery(node, RelOptUtil.Logic.TRUE_FALSE);
                 }
                 return;
             case IN:
@@ -2171,8 +2183,7 @@ private void findSubQueries(
                                     || kind == SqlKind.NOT_IN
                                     || kind == SqlKind.SOME
                                     || kind == SqlKind.ALL
-                                    || registerOnlyScalarSubQueries,
-                            clause);
+                                    || registerOnlyScalarSubQueries);
                 }
             }
         } else if (node instanceof SqlNodeList) {
@@ -2185,8 +2196,7 @@ private void findSubQueries(
                                 || kind == SqlKind.NOT_IN
                                 || kind == SqlKind.SOME
                                 || kind == SqlKind.ALL
-                                || registerOnlyScalarSubQueries,
-                        clause);
+                                || registerOnlyScalarSubQueries);
             }
         }
 
@@ -2223,20 +2233,12 @@ private void findSubQueries(
                                                 bb.getValidator(), bb.scope, (SqlCall) node)
                                 != null) {
                     findSubQueries(
-                            bb,
-                            ((SqlCall) node).operand(0),
-                            logic,
-                            registerOnlyScalarSubQueries,
-                            clause);
+                            bb, ((SqlCall) node).operand(0), logic, registerOnlyScalarSubQueries);
                     findSubQueries(
-                            bb,
-                            ((SqlCall) node).operand(1),
-                            logic,
-                            registerOnlyScalarSubQueries,
-                            clause);
+                            bb, ((SqlCall) node).operand(1), logic, registerOnlyScalarSubQueries);
                     break;
                 }
-                bb.registerSubQuery(node, logic, clause);
+                bb.registerSubQuery(node, logic);
                 break;
             default:
                 break;
@@ -2350,6 +2352,7 @@ private RexNode convertLambda(Blackboard bb, SqlNode node) {
 
     private RexNode convertOver(Blackboard bb, SqlNode node) {
         SqlCall call = (SqlCall) node;
+        bb.getValidator().deriveType(bb.scope, call);
         SqlCall aggCall = call.operand(0);
         boolean ignoreNulls = false;
         switch (aggCall.getKind()) {
@@ -3137,7 +3140,7 @@ protected void convertCollectionTable(Blackboard bb, SqlCall call) {
                     clazz ->
                             Schemas.getTableExpression(
                                     requireNonNull(schema, "schema").plus(),
-                                    Util.last(udf.getNameAsId().names),
+                                    last(udf.getNameAsId().names),
                                     table,
                                     clazz);
             RelOptTable relOptTable =
@@ -3684,7 +3687,9 @@ private RexNode convertUsing(
         final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
         final List<RexNode> list = new ArrayList<>();
         for (String name : nameList) {
-            List<RexNode> operands = new ArrayList<>();
+            // For each field joined on we compare the types from the left and right relation
+            List<RexNode> operands = new ArrayList<>(2);
+            List<RelDataType> comparedTypes = new ArrayList<>(2);
             int offset = 0;
             for (SqlValidatorNamespace n : ImmutableList.of(leftNamespace, rightNamespace)) {
                 final RelDataType rowType = n.getRowType();
@@ -3698,11 +3703,38 @@ private RexNode convertUsing(
                                     + " with "
                                     + nameMatcher);
                 }
+
+                comparedTypes.add(field.getType());
                 operands.add(rexBuilder.makeInputRef(field.getType(), offset + field.getIndex()));
                 offset += rowType.getFieldList().size();
             }
-            list.add(rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, operands));
+
+            // FLINK MODIFICATION BEGIN
+            RelDataType resultType =
+                    validator().config().typeCoercionEnabled()
+                            ? validator()
+                                    .getTypeCoercion()
+                                    .commonTypeForBinaryComparison(
+                                            comparedTypes.get(0), comparedTypes.get(1))
+                            : null;
+            if (resultType == null) {
+                // Leave call unchanged (as it happens in TypeCoercionImpl#binaryComparisonCoercion)
+                list.add(rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, operands));
+            } else {
+                List<RexNode> castedOperands = new ArrayList<>();
+                for (int i = 0; i < operands.size(); i++) {
+                    RexNode operand = operands.get(i);
+                    RelDataType fieldType = comparedTypes.get(i);
+                    RexNode expr = operand;
+                    if (!fieldType.equals(resultType)) {
+                        expr = rexBuilder.makeCast(resultType, operand, true, false);
+                    }
+                    castedOperands.add(expr);
+                }
+                list.add(rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, castedOperands));
+            }
         }
+        // FLINK MODIFICATION END
         return RexUtil.composeConjunction(rexBuilder, list);
     }
 
@@ -3737,51 +3769,53 @@ private static JoinRelType convertJoinType(JoinType joinType) {
      * @param bb Scope within which to resolve identifiers
      * @param select Query
      * @param orderExprList Additional expressions needed to implement ORDER BY
+     * @param extraList Additional expressions needed to implement QUALIFY
      */
-    protected void convertAgg(Blackboard bb, SqlSelect select, List<SqlNode> orderExprList) {
+    protected void convertAgg(
+            Blackboard bb, SqlSelect select, List<SqlNode> orderExprList, List<SqlNode> extraList) {
         requireNonNull(bb.root, "bb.root");
-        SqlNodeList groupList = select.getGroup();
-        SqlNodeList selectList = select.getSelectList();
-        SqlNode having = select.getHaving();
+        List<SqlNode> groupList = first(select.getGroup(), ImmutableList.of());
+        List<SqlNode> selectList = select.getSelectList();
+        @Nullable SqlNode having = select.getHaving();
 
         final AggConverter aggConverter =
                 AggConverter.create(
                         bb,
                         (AggregatingSelectScope) validator().getSelectScope(select),
                         validator());
-        createAggImpl(bb, aggConverter, selectList, groupList, having, orderExprList);
+        createAggImpl(bb, aggConverter, selectList, groupList, having, orderExprList, extraList);
     }
 
     private void createAggImpl(
             Blackboard bb,
             final AggConverter aggConverter,
-            SqlNodeList selectList,
-            @Nullable SqlNodeList groupList,
+            List<SqlNode> selectList,
+            List<SqlNode> groupList,
             @Nullable SqlNode having,
-            List<SqlNode> orderExprList) {
+            List<SqlNode> orderExprList,
+            List<SqlNode> extraList) {
         // Find aggregate functions in SELECT and HAVING clause
         final AggregateFinder aggregateFinder = new AggregateFinder();
-        selectList.accept(aggregateFinder);
+        aggregateFinder.visitAll(selectList);
         if (having != null) {
             having.accept(aggregateFinder);
         }
 
         // first replace the sub-queries inside the aggregates
         // because they will provide input rows to the aggregates.
-        replaceSubQueries(bb, aggregateFinder.list, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
+        aggregateFinder.list.forEach(
+                e -> replaceSubQueries(bb, e, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN));
 
         // also replace sub-queries inside filters in the aggregates
-        replaceSubQueries(bb, aggregateFinder.filterList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
+        aggregateFinder.filterList.forEach(
+                e -> replaceSubQueries(bb, e, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN));
 
         // also replace sub-queries inside ordering spec in the aggregates
-        replaceSubQueries(bb, aggregateFinder.orderList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
-        // If group-by clause is missing, pretend that it has zero elements.
-        if (groupList == null) {
-            groupList = SqlNodeList.EMPTY;
-        }
+        aggregateFinder.orderList.forEach(
+                e -> replaceSubQueries(bb, e, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN));
 
-        replaceSubQueries(
-                bb, groupList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN, SqlImplementor.Clause.GROUP_BY);
+        // also replace sub-queries inside GROUP BY
+        groupList.forEach(e -> replaceSubQueries(bb, e, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN));
 
         // register the group exprs
 
@@ -3806,9 +3840,11 @@ private void createAggImpl(
             // convert the select and having expressions, so that the
             // agg converter knows which aggregations are required
 
-            selectList.accept(aggConverter);
-            // Assert we don't have dangling items left in the stack
-            assert !aggConverter.inOver;
+            for (SqlNode expr : selectList) {
+                expr.accept(aggConverter);
+                // Assert we don't have dangling items left in the stack
+                assert !aggConverter.inOver;
+            }
             for (SqlNode expr : orderExprList) {
                 expr.accept(aggConverter);
                 assert !aggConverter.inOver;
@@ -3817,6 +3853,10 @@ private void createAggImpl(
                 having.accept(aggConverter);
                 assert !aggConverter.inOver;
             }
+            for (SqlNode expr : extraList) {
+                expr.accept(aggConverter);
+                assert !aggConverter.inOver;
+            }
 
             // compute inputs to the aggregator
             final PairList<RexNode, @Nullable String> preExprs;
@@ -3867,9 +3907,7 @@ private void createAggImpl(
 
             // Tell bb which of group columns are sorted.
             bb.columnMonotonicities.clear();
-            for (SqlNode groupItem : groupList) {
-                bb.columnMonotonicities.add(bb.scope.getMonotonicity(groupItem));
-            }
+            groupList.forEach(e -> bb.columnMonotonicities.add(bb.scope.getMonotonicity(e)));
 
             // Add the aggregator
             bb.setRoot(
@@ -3891,11 +3929,7 @@ private void createAggImpl(
             // This needs to be done separately from the sub-query inside
             // any aggregate in the select list, and after the aggregate rel
             // is allocated.
-            replaceSubQueries(
-                    bb,
-                    selectList,
-                    RelOptUtil.Logic.TRUE_FALSE_UNKNOWN,
-                    SqlImplementor.Clause.SELECT);
+            selectList.forEach(e -> replaceSubQueries(bb, e, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN));
 
             // Now sub-queries in the entire select list have been converted.
             // Convert the select expressions to get the final list to be
@@ -3924,6 +3958,9 @@ private void createAggImpl(
             for (SqlNode expr : orderExprList) {
                 projects.add(bb.convertExpression(expr), SqlValidatorUtil.alias(expr, k++));
             }
+            for (SqlNode expr : extraList) {
+                projects.add(bb.convertExpression(expr), SqlValidatorUtil.alias(expr, k++));
+            }
         } finally {
             bb.agg = null;
         }
@@ -3948,9 +3985,7 @@ private void createAggImpl(
 
         // Tell bb which of group columns are sorted.
         bb.columnMonotonicities.clear();
-        for (SqlNode selectItem : selectList) {
-            bb.columnMonotonicities.add(bb.scope.getMonotonicity(selectItem));
-        }
+        selectList.forEach(e -> bb.columnMonotonicities.add(bb.scope.getMonotonicity(e)));
     }
 
     /**
@@ -4198,7 +4233,7 @@ private RelNode createUnion(SqlCall call, RelNode left, RelNode right) {
                 }
             }
         }
-        return LogicalUnion.create(ImmutableList.of(left, right), all);
+        return relBuilder.push(left).push(right).union(all, 2).build();
     }
 
     /**
@@ -5042,18 +5077,60 @@ public SqlNode getNode() {
         return ret;
     }
 
+    /**
+     * Converts a select-list for an aggregate or non-aggregate query, adding a filter for a QUALIFY
+     * clause if present.
+     */
     private void convertSelectList(
-            Blackboard bb, Blackboard measureBb, SqlSelect select, List<SqlNode> orderList) {
-        SqlNodeList selectList = select.getSelectList();
-        selectList = validator().expandStar(selectList, select, false);
+            Blackboard bb,
+            Blackboard measureBb,
+            SqlSelect select,
+            List<SqlNode> orderExprList,
+            List<SqlNode> extraList,
+            @Nullable SqlNode qualify) {
+        if (qualify != null) {
+            // Add the QUALIFY expression to the select-list,
+            // convert the extended list,
+            // filter by the last field,
+            // and remove the last field.
+            convertSelectList(
+                    bb,
+                    measureBb,
+                    select,
+                    orderExprList,
+                    ImmutableList.of(addAlias(qualify, "QualifyExpression")),
+                    null);
+            bb.setRoot(
+                    relBuilder
+                            .push(bb.root())
+                            .filter(last(relBuilder.fields())) // filter on last column
+                            .project(skipLast(relBuilder.fields())) // remove last column
+                            .build(),
+                    false);
+            return;
+        }
 
-        replaceSubQueries(bb, selectList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
-        replaceSubQueries(
-                bb,
-                new SqlNodeList(orderList, SqlParserPos.ZERO),
-                RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
+        if (validator().isAggregate(select)) {
+            convertAgg(bb, select, orderExprList, extraList);
+        } else {
+            convertNonAggregateSelectList(bb, measureBb, select, orderExprList, extraList);
+        }
+    }
 
-        List<String> fieldNames = new ArrayList<>();
+    /** Converts the select-list of a non-aggregate query. */
+    private void convertNonAggregateSelectList(
+            Blackboard bb,
+            Blackboard measureBb,
+            SqlSelect select,
+            List<SqlNode> orderList,
+            List<SqlNode> extraList) {
+        final SqlNodeList selectList =
+                validator().expandStar(select.getSelectList(), select, false);
+
+        Iterables.concat(selectList, orderList, extraList)
+                .forEach(e -> replaceSubQueries(bb, e, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN));
+
+        final List<String> fieldNames = new ArrayList<>();
         final List<RexNode> exprs = new ArrayList<>();
         final Collection<String> aliases = new TreeSet<>();
 
@@ -5082,7 +5159,7 @@ private void convertSelectList(
             fieldNames.add(deriveAlias(expr, aliases, i));
         }
 
-        // Project extra fields for sorting.
+        // Project extra fields for ORDER BY.
         for (SqlNode expr : orderList) {
             ++i;
             SqlNode expr2 = validator().expandOrderExpr(select, expr);
@@ -5090,11 +5167,18 @@ private void convertSelectList(
             fieldNames.add(deriveAlias(expr, aliases, i));
         }
 
-        fieldNames =
+        // Project extra fields for QUALIFY.
+        for (SqlNode expr : extraList) {
+            ++i;
+            exprs.add(bb.convertExpression(expr));
+            fieldNames.add(deriveAlias(expr, aliases, i));
+        }
+
+        final List<String> uniqueFieldNames =
                 SqlValidatorUtil.uniquify(
                         fieldNames, catalogReader.nameMatcher().isCaseSensitive());
 
-        relBuilder.push(bb.root()).projectNamed(exprs, fieldNames, true);
+        relBuilder.push(bb.root()).projectNamed(exprs, uniqueFieldNames, true);
 
         RelNode project = relBuilder.build();
 
@@ -5109,7 +5193,10 @@ private void convertSelectList(
                     relBuilder
                             .push(bb.root())
                             .projectNamed(
-                                    project1.getProjects(), fieldNames, true, ImmutableSet.of(p.id))
+                                    project1.getProjects(),
+                                    uniqueFieldNames,
+                                    true,
+                                    ImmutableSet.of(p.id))
                             .build();
         } else {
             r = project;
@@ -5160,118 +5247,6 @@ private static String deriveAlias(
         return alias;
     }
 
-    private void convertQualify(Blackboard bb, @Nullable SqlNode qualify) {
-        if (qualify == null) {
-            return;
-        }
-
-        final LogicalProject projectionFromSelect =
-                requireNonNull((LogicalProject) bb.root, "root");
-
-        // Convert qualify SqlNode to a RexNode
-        replaceSubQueries(bb, qualify, RelOptUtil.Logic.UNKNOWN_AS_FALSE);
-        final RelNode originalRoot = requireNonNull(bb.root, "root");
-        RexNode qualifyRexNode;
-        try {
-            // Set the root to the input of the project,
-            // since QUALIFY might have an expression in the OVER clause
-            // that references a column not in the SELECT.
-            bb.setRoot(projectionFromSelect.getInput(), false);
-            qualifyRexNode = bb.convertExpression(qualify);
-        } finally {
-            bb.setRoot(originalRoot, false);
-        }
-
-        // Check to see if the qualify expression has a referenced expression and
-        // do some referencing accordingly
-        final RexNode qualifyWithReferencesRexNode =
-                qualifyRexNode.accept(new DuplicateEliminator(projectionFromSelect.getProjects()));
-
-        // Create a Project with the QUALIFY expression
-        if (qualifyWithReferencesRexNode.equals(qualifyRexNode)) {
-            // The QUALIFY expression does not depend on any references like so:
-            //
-            //  SELECT A, B
-            //  FROM tbl
-            //  QUALIFY WINDOW(C) = 1
-            //
-            // Meaning we should generate a plan like:
-            //  Project(A, B, WINDOW(C) = 1 as QualifyExpression)
-            //    TableScan(tbl)
-            //
-            relBuilder
-                    .push(projectionFromSelect.getInput())
-                    .project(
-                            append(projectionFromSelect.getProjects(), qualifyRexNode),
-                            append(
-                                    projectionFromSelect.getRowType().getFieldNames(),
-                                    "QualifyExpression"));
-        } else {
-            // The QUALIFY expression depended on a reference meaning
-            // we need to introduce an extra project like so:
-            //
-            //  SELECT A, B, WINDOW(C) as window_val
-            //  FROM tbl
-            //  QUALIFY window_val = 1
-            //
-            // Meaning we should generate a plan like:
-            //
-            //  Project($0, $1, $2, =($2, 1) as QualifyExpression)
-            //    Project(A, B, WINDOW(C) as window_val)
-            //      TableScan(tbl)
-            //
-            // This is a very specific application of Common Subexpression Elimination
-            // (CSE), since the window value pops up twice.
-            relBuilder
-                    .push(requireNonNull(bb.root, "root"))
-                    .project(
-                            append(relBuilder.fields(), qualifyWithReferencesRexNode),
-                            append(
-                                    relBuilder.peek().getRowType().getFieldNames(),
-                                    "QualifyExpression"));
-        }
-
-        // Filter on that extra column
-        relBuilder.filter(Util.last(relBuilder.fields()));
-
-        // Remove that extra column from the projection
-        relBuilder.project(
-                Util.first(relBuilder.fields(), projectionFromSelect.getProjects().size()));
-
-        // Update the root
-        bb.setRoot(relBuilder.build(), false);
-    }
-
-    /**
-     * Eliminates a common sub-expression by looking for a {@link RexNode} in the expressions of a
-     * {@link Project}; if found, returns a refIndex instead of the raw node.
-     */
-    private static final class DuplicateEliminator extends RexShuttle {
-        private final List<RexNode> projects;
-
-        DuplicateEliminator(List<RexNode> projects) {
-            this.projects = projects;
-        }
-
-        @Override
-        public RexNode visitCall(RexCall call) {
-            final int i = projects.indexOf(call);
-            if (i >= 0) {
-                return new RexInputRef(i, projects.get(i).getType());
-            }
-            return super.visitCall(call);
-        }
-
-        @Override
-        public RexNode visitOver(RexOver over) {
-            final int i = projects.indexOf(over);
-            if (i >= 0) {
-                return new RexInputRef(i, projects.get(i).getType());
-            }
-            return over;
-        }
-    }
-
     /** Converts a WITH sub-query into a relational expression. */
     public RelRoot convertWith(SqlWith with, boolean top) {
         return convertQuery(with.body, false, top);
@@ -5813,30 +5788,26 @@ public void flatten(
             }
         }
 
-        void registerSubQuery(SqlNode node, RelOptUtil.Logic logic, SqlImplementor.Clause clause) {
-            if (getSubQuery(node, clause) == null) {
-                subQueryList.add(new SubQuery(node, logic, clause));
+        void registerSubQuery(SqlNode node, RelOptUtil.Logic logic) {
+            for (SubQuery subQuery : subQueryList) {
+                // Compare the reference to make sure the matched node has
+                // exact scope where it belongs.
+                if (node == subQuery.node) {
+                    return;
+                }
             }
+            subQueryList.add(new SubQuery(node, logic));
         }
 
-        @Nullable SubQuery getSubQuery(SqlNode expr, SqlImplementor.Clause exprClause) {
+        @Nullable SubQuery getSubQuery(SqlNode expr) {
             for (SubQuery subQuery : subQueryList) {
                 // Compare the reference to make sure the matched node has
                 // exact scope where it belongs.
                 if (expr == subQuery.node) {
                     return subQuery;
                 }
-
-                // Reference comparing does not work in case when select list has column which
-                // refers
-                // to the column inside `GROUP BY` clause.
-                // For example: SELECT deptno IN (1,2) FROM emp.deptno GROUP BY deptno IN (1,2);
-                if (exprClause == SqlImplementor.Clause.SELECT
-                        && subQuery.clause == SqlImplementor.Clause.GROUP_BY
-                        && expr.equalsDeep(subQuery.node, Litmus.IGNORE)) {
-                    return subQuery;
-                }
             }
+
             return null;
         }
 
@@ -5918,28 +5889,7 @@ public RexNode convertExpression(SqlNode expr) {
                             if (correlationUse != null) {
                                 rel = correlationUse.r;
                             }
-
-                            switch (kind) {
-                                case IN:
-                                    return RexSubQuery.in(rel, list);
-                                case NOT_IN:
-                                    return rexBuilder.makeCall(
-                                            SqlStdOperatorTable.NOT, RexSubQuery.in(rel, list));
-                                case SOME:
-                                    return RexSubQuery.some(
-                                            rel, list, (SqlQuantifyOperator) call.getOperator());
-                                case ALL:
-                                    return rexBuilder.makeCall(
-                                            SqlStdOperatorTable.NOT,
-                                            RexSubQuery.some(
-                                                    rel,
-                                                    list,
-                                                    negate(
-                                                            (SqlQuantifyOperator)
-                                                                    call.getOperator())));
-                                default:
-                                    throw new AssertionError(kind);
-                            }
+                            return createSubquery(kind, rel, list, call);
                         }
                         break;
 
@@ -6018,7 +5968,7 @@ public RexNode convertExpression(SqlNode expr) {
                 case CURSOR:
                 case IN:
                 case NOT_IN:
-                    subQuery = getSubQuery(expr, null);
+                    subQuery = getSubQuery(expr);
                     if (subQuery == null && (kind == SqlKind.SOME || kind == SqlKind.ALL)) {
                         break;
                     }
@@ -6033,7 +5983,7 @@ public RexNode convertExpression(SqlNode expr) {
                 case ARRAY_QUERY_CONSTRUCTOR:
                 case MAP_QUERY_CONSTRUCTOR:
                 case MULTISET_QUERY_CONSTRUCTOR:
-                    subQuery = requireNonNull(getSubQuery(expr, null));
+                    subQuery = requireNonNull(getSubQuery(expr));
                     rex = requireNonNull(subQuery.expr);
 
                     if (((kind == SqlKind.SCALAR_QUERY) || (kind == SqlKind.EXISTS))
@@ -6235,7 +6185,7 @@ public SqlNode validateExpression(RelDataType rowType, SqlNode expr) {
 
         @Override
         public RexRangeRef getSubQueryExpr(SqlCall call) {
-            final SubQuery subQuery = requireNonNull(getSubQuery(call, null));
+            final SubQuery subQuery = requireNonNull(getSubQuery(call));
             return (RexRangeRef) requireNonNull(subQuery.expr, () -> "subQuery.expr for " + call);
         }
 
@@ -6330,6 +6280,28 @@ public List<SqlMonotonicity> getColumnMonotonicities() {
         }
     }
 
+    /** Creates an sub-query of type {@code IN, NOT IN, SOME, or ALL}. */
+    private RexNode createSubquery(
+            SqlKind kind, RelNode rel, ImmutableList<RexNode> list, @Nullable SqlCall call) {
+        switch (kind) {
+            case IN:
+                return RexSubQuery.in(rel, list);
+            case NOT_IN:
+                return rexBuilder.makeCall(SqlStdOperatorTable.NOT, RexSubQuery.in(rel, list));
+            case SOME:
+                assert call != null;
+                return RexSubQuery.some(rel, list, (SqlQuantifyOperator) call.getOperator());
+            case ALL:
+                assert call != null;
+                return rexBuilder.makeCall(
+                        SqlStdOperatorTable.NOT,
+                        RexSubQuery.some(
+                                rel, list, negate((SqlQuantifyOperator) call.getOperator())));
+            default:
+                throw new AssertionError(kind);
+        }
+    }
+
     private static SqlQuantifyOperator negate(SqlQuantifyOperator operator) {
         assert operator.kind == SqlKind.ALL;
         return SqlStdOperatorTable.some(operator.comparisonKind.negateNullSafe());
@@ -6623,12 +6595,10 @@ private static class SubQuery {
         final SqlNode node;
         final RelOptUtil.Logic logic;
         @Nullable RexNode expr;
-        final SqlImplementor.Clause clause;
 
-        private SubQuery(SqlNode node, RelOptUtil.Logic logic, SqlImplementor.Clause clause) {
+        private SubQuery(SqlNode node, RelOptUtil.Logic logic) {
             this.node = node;
             this.logic = logic;
-            this.clause = clause;
         }
     }
 
@@ -6676,10 +6646,10 @@ public Boolean visit(SqlIntervalQualifier intervalQualifier) {
 
     /** Visitor that collects all aggregate functions in a {@link SqlNode} tree. */
     private static class AggregateFinder extends SqlBasicVisitor<Void> {
-        final SqlNodeList list = new SqlNodeList(SqlParserPos.ZERO);
-        final SqlNodeList filterList = new SqlNodeList(SqlParserPos.ZERO);
-        final SqlNodeList distinctList = new SqlNodeList(SqlParserPos.ZERO);
-        final SqlNodeList orderList = new SqlNodeList(SqlParserPos.ZERO);
+        final List<SqlNode> list = new ArrayList<>();
+        final List<SqlNode> filterList = new ArrayList<>();
+        final List<SqlNode> distinctList = new ArrayList<>();
+        final List<SqlNode> orderList = new ArrayList<>();
 
         @Override
         public Void visit(SqlCall call) {
@@ -6702,7 +6672,7 @@ public Void visit(SqlCall call) {
                 final SqlNode aggCall = call.getOperandList().get(0);
                 final SqlNodeList distinctList = (SqlNodeList) call.getOperandList().get(1);
                 list.add(aggCall);
-                this.distinctList.addAll(distinctList.getList());
+                this.distinctList.addAll(distinctList);
                 return null;
             }
 
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkCalciteSqlValidator.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkCalciteSqlValidator.java
index 77a1634fa0bc2..3c992234d1762 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkCalciteSqlValidator.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/calcite/FlinkCalciteSqlValidator.java
@@ -437,6 +437,17 @@ public SqlNode maybeCast(SqlNode node, RelDataType currentType, RelDataType desi
         return super.maybeCast(node, currentType, desiredType);
     }
 
+    /*
+     *[CALCITE-6645] is the reason.
+     */
+    @Override
+    public @Nullable SqlCall makeNullaryCall(SqlIdentifier id) {
+        if (id.names.size() == 1 && !id.isComponentQuoted(0)) {
+            return super.makeNullaryCall(id);
+        }
+        return null;
+    }
+
     // --------------------------------------------------------------------------------------------
     // Column expansion
     // --------------------------------------------------------------------------------------------
diff --git a/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE b/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
index 9d88763d0746d..46d96857eb13f 100644
--- a/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
+++ b/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
@@ -8,9 +8,9 @@ This project bundles the following dependencies under the Apache Software Licens
 
 - com.google.guava:guava:33.4.0-jre
 - com.google.guava:failureaccess:1.0.2
-- org.apache.calcite:calcite-core:1.38.0
-- org.apache.calcite:calcite-linq4j:1.38.0
-- org.apache.calcite.avatica:avatica-core:1.25.0
+- org.apache.calcite:calcite-core:1.39.0
+- org.apache.calcite:calcite-linq4j:1.39.0
+- org.apache.calcite.avatica:avatica-core:1.26.0
 - org.apache.commons:commons-math3:3.6.1
 - org.apache.commons:commons-text:1.10.0
 - commons-codec:commons-codec:1.15
diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/TemporalJoinUtil.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/TemporalJoinUtil.scala
index 47bed3b4b2487..7ab1f8c54adb8 100644
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/TemporalJoinUtil.scala
+++ b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/TemporalJoinUtil.scala
@@ -443,9 +443,6 @@ object TemporalJoinUtil {
     while (true) {
       var expr = rexProgram.getExprList.get(index)
       expr match {
-        case call: RexCall if call.getOperator == SqlStdOperatorTable.IN_FENNEL =>
-          // drill through identity function
-          expr = call.getOperands.get(0)
         case call: RexCall if call.getOperator == SqlStdOperatorTable.CAST =>
           // drill through identity function
           val outputType = call.getType
diff --git a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/functions/CastFunctionITCase.java b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/functions/CastFunctionITCase.java
index 5420ce1987f10..558ee557a4dea 100644
--- a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/functions/CastFunctionITCase.java
+++ b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/functions/CastFunctionITCase.java
@@ -1136,7 +1136,8 @@ private static List<TestSetSpec> toStringCasts() {
                         .fromCase(INTERVAL(MONTH()), 5, "+0-05")
                         .fromCase(INTERVAL(MONTH()), 123, "+10-03")
                         .fromCase(INTERVAL(MONTH()), 12334, "+1027-10")
-                        .fromCase(INTERVAL(DAY()), 10, "+0 00:00:00.010")
+                        // CALCITE-6714
+                        .fromCase(INTERVAL(DAY()), 10, "+0 00:00:10.000")
                         .fromCase(INTERVAL(DAY()), 123456789L, "+1 10:17:36.789")
                         .fromCase(INTERVAL(DAY()), Duration.ofHours(36), "+1 12:00:00.000")
                         .fromCase(ARRAY(INT().nullable()), new Integer[] {null, 456}, "[NULL, 456]")
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/CalcTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/CalcTest.xml
index 3f77f12429dc9..67b58eb33ee13 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/CalcTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/CalcTest.xml
@@ -254,7 +254,7 @@ Calc(select=[a, b, CAST('xx' AS VARCHAR(2147483647)) AS c], where=[((SEARCH(b, S
     <Resource name="ast">
       <![CDATA[
 LogicalProject(EXPR$0=[ROW($0, $1, $2)], EXPR$1=[ARRAY(12, $1)], EXPR$2=[MAP($0, $2)])
-+- LogicalFilter(condition=[AND(=($0, _UTF-16LE'foo'), =($1, 12), =($2, 1984-07-12 14:34:24))])
++- LogicalFilter(condition=[AND(=($0, CAST(_UTF-16LE'foo'):VARCHAR(2147483647) CHARACTER SET "UTF-16LE"), =($1, CAST(12):INTEGER), =($2, CAST(1984-07-12 14:34:24):TIMESTAMP(3)))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable5]])
 ]]>
     </Resource>
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 14a58b5a56edb..635430d71ebf6 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,7 +33,7 @@ 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=[right])
+   +- HashJoin(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(a, a0) AND IS NOT DISTINCT FROM(b, b0) AND IS NOT DISTINCT FROM(c, c0))], 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]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DynamicFunctionPlanTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DynamicFunctionPlanTest.xml
index c4442ef5dde99..37afe873a8ed6 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DynamicFunctionPlanTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DynamicFunctionPlanTest.xml
@@ -34,10 +34,11 @@ LogicalAggregate(group=[{0, 1}], EXPR$2=[SUM($2)], EXPR$3=[COUNT()])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashAggregate(isMerge=[false], groupBy=[cat], auxGrouping=[gmt_date], select=[cat, gmt_date, SUM(cnt) AS EXPR$2, COUNT(*) AS EXPR$3])
-+- Exchange(distribution=[hash[cat]])
-   +- Calc(select=[cat, gmt_date, cnt], where=[(gmt_date = CURRENT_DATE())])
-      +- TableSourceScan(table=[[default_catalog, default_database, src, filter=[], project=[cat, gmt_date, cnt], metadata=[]]], fields=[cat, gmt_date, cnt])
+Calc(select=[cat, CAST(CURRENT_DATE() AS DATE) AS gmt_date, EXPR$2, EXPR$3])
++- HashAggregate(isMerge=[false], groupBy=[cat], select=[cat, SUM(cnt) AS EXPR$2, COUNT(*) AS EXPR$3])
+   +- Exchange(distribution=[hash[cat]])
+      +- Calc(select=[cat, cnt], where=[(gmt_date = CURRENT_DATE())])
+         +- TableSourceScan(table=[[default_catalog, default_database, src, filter=[], project=[cat, gmt_date, cnt], metadata=[]]], fields=[cat, gmt_date, cnt])
 ]]>
     </Resource>
   </TestCase>
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 4cd9988c45877..94a0c654cfbf7 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
@@ -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=[right])
+      +- HashJoin(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(a, d) AND IS NOT DISTINCT FROM(b, e))], select=[a, b], build=[right])
          :- Exchange(distribution=[hash[a, b]])
          :  +- Calc(select=[a, b])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1]], fields=[a, b, c])
@@ -258,7 +258,7 @@ 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=[right])
+   +- HashJoin(joinType=[LeftAntiJoin], where=[(IS NOT DISTINCT FROM(a, a0) AND IS NOT DISTINCT FROM(b, b0) AND IS NOT DISTINCT FROM(c, c0))], select=[a, b, c], build=[right])
       :- Exchange(distribution=[hash[a, b, c]], shuffle_mode=[BATCH])
       :  +- TableSourceScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c])(reuse_id=[1])
       +- Exchange(distribution=[hash[a, b, c]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ReplaceIntersectWithSemiJoinRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ReplaceIntersectWithSemiJoinRuleTest.xml
index d6e3d11936d51..fc8dbccb4f8f0 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ReplaceIntersectWithSemiJoinRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ReplaceIntersectWithSemiJoinRuleTest.xml
@@ -112,7 +112,7 @@ LogicalProject(c=[$2])
 LogicalProject(c=[$2])
 +- LogicalFilter(condition=[>($0, 1)])
    +- LogicalAggregate(group=[{0, 1, 2}])
-      +- LogicalJoin(condition=[AND(OR(=($0, $3), AND(IS NULL($0), IS NULL($3))), OR(=($1, $4), AND(IS NULL($1), IS NULL($4))), OR(=($2, $5), AND(IS NULL($2), IS NULL($5))))], joinType=[semi])
+      +- LogicalJoin(condition=[AND(IS NOT DISTINCT FROM($0, $3), IS NOT DISTINCT FROM($1, $4), IS NOT DISTINCT FROM($2, $5))], joinType=[semi])
          :- LogicalProject(a=[$0], b=[$1], c=[$2])
          :  +- LogicalTableScan(table=[[default_catalog, default_database, T1]])
          +- LogicalProject(d=[$0], e=[$1], f=[$2])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ReplaceMinusWithAntiJoinRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ReplaceMinusWithAntiJoinRuleTest.xml
index 451ca7854084d..c2aa2834a7157 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ReplaceMinusWithAntiJoinRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/ReplaceMinusWithAntiJoinRuleTest.xml
@@ -112,7 +112,7 @@ LogicalProject(c=[$2])
 LogicalProject(c=[$2])
 +- LogicalFilter(condition=[<($1, 2)])
    +- LogicalAggregate(group=[{0, 1, 2}])
-      +- LogicalJoin(condition=[AND(OR(=($0, $3), AND(IS NULL($0), IS NULL($3))), OR(=($1, $4), AND(IS NULL($1), IS NULL($4))), OR(=($2, $5), AND(IS NULL($2), IS NULL($5))))], joinType=[anti])
+      +- LogicalJoin(condition=[AND(IS NOT DISTINCT FROM($0, $3), IS NOT DISTINCT FROM($1, $4), IS NOT DISTINCT FROM($2, $5))], joinType=[anti])
          :- LogicalProject(a=[$0], b=[$1], c=[$2])
          :  +- LogicalTableScan(table=[[default_catalog, default_database, T1]])
          +- LogicalProject(d=[$0], e=[$1], f=[$2])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/WindowGroupReorderRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/WindowGroupReorderRuleTest.xml
index 6f52e40e10da6..e05e2c722a6de 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/WindowGroupReorderRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/WindowGroupReorderRuleTest.xml
@@ -115,7 +115,7 @@ LogicalProject(EXPR$0=[COUNT() OVER (PARTITION BY $2 ORDER BY $0 NULLS FIRST RAN
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(EXPR$0=[$2], EXPR$1=[CASE(>($3, 0), $4, null:INTEGER)], EXPR$2=[$7], EXPR$3=[CASE(>($5, 0), $6, null:INTEGER)], EXPR$4=[$8])
-+- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] range between $2 PRECEDING and $3 FOLLOWING aggs [COUNT()])], window#1=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), SUM($0)])], window#2=[window(partition {1} order by [0 ASC-nulls-first] range between $4 PRECEDING and $3 FOLLOWING aggs [COUNT($0), SUM($0)])], window#3=[window(partition {1} order by [0 ASC-nulls-first, 1 ASC-nulls-first] aggs [RANK()])], window#4=[window(partition {1} order by [1 ASC-nulls-first] rows between $4 PRECEDING and $3 FOLLOWING aggs [COUNT()])])
++- LogicalWindow(window#0=[window(partition {1} order by [0 ASC-nulls-first] range between $2 PRECEDING and $3 FOLLOWING aggs [COUNT()])], window#1=[window(partition {1} order by [0 ASC-nulls-first] aggs [COUNT($0), SUM($0)])], window#2=[window(partition {1} order by [0 ASC-nulls-first] range between $4 PRECEDING and $3 FOLLOWING aggs [COUNT($0), SUM($0)])], window#3=[window(partition {1} order by [0 ASC-nulls-first, 1 ASC-nulls-first] aggs [RANK()])], window#4=[window(partition {1} order by [1 ASC-nulls-first] rows between $4 PRECEDING and $3 FOLLOWING aggs [COUNT()])], constants=[[-1, 10, 1]])
    +- LogicalProject(a=[$0], c=[$2])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.xml
index 3d3a6f0cc85ee..0e9221a7d8541 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.xml
@@ -65,6 +65,64 @@ LogicalProject(a=[$0], b=[$1], c=[$2])
    +- LogicalProject(e=[$1])
       +- LogicalFilter(condition=[true])
          +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testInNotInExistsNotExists2">
+    <Resource name="sql">
+      <![CDATA[SELECT c FROM l WHERE ( (CASE WHEN b IN (SELECT j FROM t WHERE l.a = t.i) THEN 1 ELSE 2 END),  (CASE WHEN NOT EXISTS (SELECT m FROM t2) THEN 3        WHEN EXISTS (select i FROM t) THEN 4 ELSE 5 END))   NOT IN (SELECT d, e FROM r)]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(c=[$2])
++- LogicalFilter(condition=[NOT(IN(CASE(IN($1, {
+LogicalProject(j=[$1])
+  LogicalFilter(condition=[=($cor0.a, $0)])
+    LogicalTableScan(table=[[default_catalog, default_database, t]])
+}), 1, 2), CASE(NOT(EXISTS({
+LogicalTableScan(table=[[default_catalog, default_database, t2]])
+})), 3, EXISTS({
+LogicalTableScan(table=[[default_catalog, default_database, t]])
+}), 4, 5), {
+LogicalProject(d=[$0], e=[$1])
+  LogicalTableScan(table=[[default_catalog, default_database, r]])
+}))], variablesSet=[[$cor0]])
+   +- LogicalTableScan(table=[[default_catalog, default_database, l]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+LogicalProject(c=[$2])
++- LogicalFilter(condition=[OR(=($3, 0), AND(IS NULL($13), >=($4, $3)))])
+   +- LogicalJoin(condition=[=(CASE(AND(IS NOT TRUE(OR(IS NULL($1), =($6, 0))), IS NOT NULL($10)), 1, 2), $11)], joinType=[left])
+      :- LogicalJoin(condition=[AND(=($0, $9), =($1, $8))], joinType=[left])
+      :  :- LogicalJoin(condition=[=($0, $5)], joinType=[left])
+      :  :  :- LogicalJoin(condition=[true], joinType=[inner])
+      :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
+      :  :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT($0, $1)])
+      :  :  :     +- LogicalProject(d=[$0], e=[$1])
+      :  :  :        +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+      :  :  +- LogicalAggregate(group=[{0}], c=[COUNT()], ck=[COUNT($1)])
+      :  :     +- LogicalProject(i=[$0], j=[$1])
+      :  :        +- LogicalFilter(condition=[IS NOT NULL($0)])
+      :  :           +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+      :  +- LogicalFilter(condition=[IS NOT NULL($0)])
+      :     +- LogicalProject(j=[$0], i2=[$1], $f2=[true])
+      :        +- LogicalAggregate(group=[{0, 1}])
+      :           +- LogicalProject(j=[$1], i2=[$0])
+      :              +- LogicalFilter(condition=[IS NOT NULL($0)])
+      :                 +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+      +- LogicalJoin(condition=[true], joinType=[left])
+         :- LogicalJoin(condition=[true], joinType=[left])
+         :  :- LogicalFilter(condition=[=(4, $1)])
+         :  :  +- LogicalProject(d=[$0], e=[$1], $f2=[true])
+         :  :     +- LogicalAggregate(group=[{0, 1}])
+         :  :        +- LogicalProject(d=[$0], e=[$1])
+         :  :           +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+         :  +- LogicalProject($f0=[true], dummy=[$0])
+         :     +- LogicalValues(tuples=[[{ true }]])
+         +- LogicalProject($f0=[true], dummy=[$0])
+            +- LogicalValues(tuples=[[{ true }]])
 ]]>
     </Resource>
   </TestCase>
@@ -817,6 +875,81 @@ LogicalProject(a=[$0], b=[$1], c=[$2])
    +- LogicalProject(d=[$0])
       +- LogicalFilter(condition=[true])
          +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testNotInNotExists3">
+    <Resource name="sql">
+      <![CDATA[SELECT c FROM l WHERE ( (CASE WHEN NOT EXISTS (SELECT * FROM t WHERE l.a = t.i) THEN 1 ELSE 2 END),  (CASE WHEN b NOT IN (SELECT m FROM t2) THEN 3 ELSE 4 END))   NOT IN (SELECT d, e FROM r)]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(c=[$2])
++- LogicalFilter(condition=[NOT(IN(CASE(NOT(EXISTS({
+LogicalFilter(condition=[=($cor0.a, $0)])
+  LogicalTableScan(table=[[default_catalog, default_database, t]])
+})), 1, 2), CASE(NOT(IN($1, {
+LogicalProject(m=[$1])
+  LogicalTableScan(table=[[default_catalog, default_database, t2]])
+})), 3, 4), {
+LogicalProject(d=[$0], e=[$1])
+  LogicalTableScan(table=[[default_catalog, default_database, r]])
+}))], variablesSet=[[$cor0]])
+   +- LogicalTableScan(table=[[default_catalog, default_database, l]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+LogicalProject(c=[$2])
++- LogicalFilter(condition=[OR(=($3, 0), AND(IS NULL($11), >=($4, $3)))])
+   +- LogicalJoin(condition=[=(CASE(OR(=($5, 0), AND(IS NULL($8), >=($6, $5), IS NOT NULL($1))), 3, 4), $10)], joinType=[left])
+      :- LogicalJoin(condition=[=($1, $7)], joinType=[left])
+      :  :- LogicalJoin(condition=[true], joinType=[inner])
+      :  :  :- LogicalJoin(condition=[true], joinType=[inner])
+      :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
+      :  :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT($0, $1)])
+      :  :  :     +- LogicalProject(d=[$0], e=[$1])
+      :  :  :        +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+      :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT($0)])
+      :  :     +- LogicalProject(m=[$1])
+      :  :        +- LogicalTableScan(table=[[default_catalog, default_database, t2]])
+      :  +- LogicalProject(m=[$0], $f1=[true])
+      :     +- LogicalAggregate(group=[{0}])
+      :        +- LogicalProject(m=[$1])
+      :           +- LogicalTableScan(table=[[default_catalog, default_database, t2]])
+      +- LogicalJoin(condition=[=($0, $3)], joinType=[left])
+         :- LogicalFilter(condition=[=(2, $0)])
+         :  +- LogicalProject(d=[$0], e=[$1], $f2=[true])
+         :     +- LogicalAggregate(group=[{0, 1}])
+         :        +- LogicalProject(d=[$0], e=[$1])
+         :           +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+         +- LogicalProject(i1=[$0], $f1=[true])
+            +- LogicalAggregate(group=[{0}])
+               +- LogicalProject(i1=[$0])
+                  +- LogicalFilter(condition=[IS NOT NULL($0)])
+                     +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testNotInOnWhere_NotSubQuery">
+    <Resource name="sql">
+      <![CDATA[SELECT * FROM x WHERE a NOT IN (1, 2, 3, 4)]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(a=[$0], b=[$1])
++- LogicalFilter(condition=[NOT(IN($0, {
+LogicalValues(tuples=[[{ 1 }, { 2 }, { 3 }, { 4 }]])
+}))])
+   +- LogicalTableScan(table=[[default_catalog, default_database, x]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+LogicalProject(a=[$0], b=[$1])
++- LogicalJoin(condition=[OR(IS NULL($0), =($0, $2))], joinType=[anti])
+   :- LogicalTableScan(table=[[default_catalog, default_database, x]])
+   +- LogicalValues(tuples=[[{ 1 }, { 2 }, { 3 }, { 4 }]])
 ]]>
     </Resource>
   </TestCase>
@@ -2022,6 +2155,53 @@ LogicalProject(c=[$2])
       :           +- LogicalTableScan(table=[[default_catalog, default_database, t2]])
       +- LogicalProject(d=[$0], e=[$1])
          +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testNotInWithUncorrelatedOnWhere_Case7">
+    <Resource name="sql">
+      <![CDATA[SELECT b FROM l WHERE (CASE WHEN a NOT IN (SELECT i FROM t1 WHERE l.a = t1.i) THEN 1 ELSE 2 END) NOT IN (SELECT d FROM r)]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(b=[$1])
++- LogicalFilter(condition=[NOT(IN(CASE(NOT(IN($0, {
+LogicalProject(i=[$0])
+  LogicalFilter(condition=[=($cor0.a, $0)])
+    LogicalTableScan(table=[[default_catalog, default_database, t1]])
+})), 1, 2), {
+LogicalProject(d=[$0])
+  LogicalTableScan(table=[[default_catalog, default_database, r]])
+}))], variablesSet=[[$cor0]])
+   +- LogicalTableScan(table=[[default_catalog, default_database, l]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+LogicalProject(b=[$1])
++- LogicalFilter(condition=[OR(=($3, 0), AND(IS NULL($12), >=($4, $3)))])
+   +- LogicalJoin(condition=[=(CASE(OR(=($6, 0), IS NOT TRUE(OR(IS NULL($0), IS NOT NULL($10), <($7, $6)))), 1, 2), $11)], joinType=[left])
+      :- LogicalJoin(condition=[=($0, $9)], joinType=[left])
+      :  :- LogicalJoin(condition=[=($0, $5)], joinType=[left])
+      :  :  :- LogicalJoin(condition=[true], joinType=[inner])
+      :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
+      :  :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT($0)])
+      :  :  :     +- LogicalProject(d=[$0])
+      :  :  :        +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+      :  :  +- LogicalAggregate(group=[{0}], c=[COUNT()], ck=[COUNT($1)])
+      :  :     +- LogicalProject(i1=[$0], i=[$0])
+      :  :        +- LogicalFilter(condition=[IS NOT NULL($0)])
+      :  :           +- LogicalTableScan(table=[[default_catalog, default_database, t1]])
+      :  +- LogicalFilter(condition=[=($1, $0)])
+      :     +- LogicalProject(i=[$0], i2=[$1], $f2=[true])
+      :        +- LogicalAggregate(group=[{0, 1}])
+      :           +- LogicalProject(i=[$0], i2=[$0])
+      :              +- LogicalFilter(condition=[IS NOT NULL($0)])
+      :                 +- LogicalTableScan(table=[[default_catalog, default_database, t1]])
+      +- LogicalProject(d=[$0], $f1=[true])
+         +- LogicalAggregate(group=[{0}])
+            +- LogicalProject(d=[$0])
+               +- LogicalTableScan(table=[[default_catalog, default_database, r]])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml
index dc8f600adbb0e..8d81faec9ddd0 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml
@@ -1520,6 +1520,74 @@ LogicalProject(a=[$0], b=[$1], c=[$2])
    +- LogicalProject(d=[$0])
       +- LogicalFilter(condition=[true])
          +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testInExists3">
+    <Resource name="sql">
+      <![CDATA[SELECT c FROM l WHERE ( (CASE WHEN EXISTS (SELECT * FROM t WHERE l.a = t.i) THEN 1 ELSE 2 END),  (CASE WHEN b IN (SELECT m FROM t2) THEN 3 ELSE 4 END))  IN (SELECT d, e FROM r)]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(c=[$2])
++- LogicalFilter(condition=[IN(CASE(EXISTS({
+LogicalFilter(condition=[=($cor0.a, $0)])
+  LogicalTableScan(table=[[default_catalog, default_database, t]])
+}), 1, 2), CASE(IN($1, {
+LogicalProject(m=[$1])
+  LogicalTableScan(table=[[default_catalog, default_database, t2]])
+}), 3, 4), {
+LogicalProject(d=[$0], e=[$1])
+  LogicalTableScan(table=[[default_catalog, default_database, r]])
+})], variablesSet=[[$cor0]])
+   +- LogicalTableScan(table=[[default_catalog, default_database, l]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+LogicalProject(c=[$2])
++- LogicalJoin(condition=[AND(=(CASE(IS NOT NULL($2), 1, 2), $7), =(CASE(AND(<>($3, 0), IS NOT NULL($6), IS NOT NULL($1)), 3, 4), $8))], joinType=[inner])
+   :- LogicalJoin(condition=[=($1, $5)], joinType=[left])
+   :  :- LogicalJoin(condition=[true], joinType=[inner])
+   :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
+   :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT($0)])
+   :  :     +- LogicalProject(m=[$1])
+   :  :        +- LogicalTableScan(table=[[default_catalog, default_database, t2]])
+   :  +- LogicalProject(m=[$0], $f1=[true])
+   :     +- LogicalAggregate(group=[{0}])
+   :        +- LogicalProject(m=[$1])
+   :           +- LogicalTableScan(table=[[default_catalog, default_database, t2]])
+   +- LogicalJoin(condition=[=($0, $2)], joinType=[left])
+      :- LogicalAggregate(group=[{0, 1}])
+      :  +- LogicalProject(d=[$0], e=[$1])
+      :     +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+      +- LogicalProject(i1=[$0], $f1=[true])
+         +- LogicalAggregate(group=[{0}])
+            +- LogicalProject(i1=[$0])
+               +- LogicalFilter(condition=[IS NOT NULL($0)])
+                  +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testInOnWhere_NotSubQuery">
+    <Resource name="sql">
+      <![CDATA[SELECT * FROM l WHERE a IN (1, 2, 3, 4)]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(a=[$0], b=[$1], c=[$2])
++- LogicalFilter(condition=[IN($0, {
+LogicalValues(tuples=[[{ 1 }, { 2 }, { 3 }, { 4 }]])
+})])
+   +- LogicalTableScan(table=[[default_catalog, default_database, l]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+LogicalProject(a=[$0], b=[$1], c=[$2])
++- LogicalJoin(condition=[=($0, $3)], joinType=[semi])
+   :- LogicalTableScan(table=[[default_catalog, default_database, l]])
+   +- LogicalValues(tuples=[[{ 1 }, { 2 }, { 3 }, { 4 }]])
 ]]>
     </Resource>
   </TestCase>
@@ -3738,6 +3806,47 @@ LogicalProject(c=[$2])
          :              +- LogicalTableScan(table=[[default_catalog, default_database, t2]])
          +- LogicalProject(d=[$0], e=[$1])
             +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testInWithUncorrelatedOnWhere_Case7">
+    <Resource name="sql">
+      <![CDATA[SELECT b FROM l WHERE (CASE WHEN a IN (SELECT i FROM t1 WHERE l.a = t1.i) THEN 1 ELSE 2 END) IN (SELECT d FROM r)]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalProject(b=[$1])
++- LogicalFilter(condition=[IN(CASE(IN($0, {
+LogicalProject(i=[$0])
+  LogicalFilter(condition=[=($cor0.a, $0)])
+    LogicalTableScan(table=[[default_catalog, default_database, t1]])
+}), 1, 2), {
+LogicalProject(d=[$0])
+  LogicalTableScan(table=[[default_catalog, default_database, r]])
+})], variablesSet=[[$cor0]])
+   +- LogicalTableScan(table=[[default_catalog, default_database, l]])
+]]>
+    </Resource>
+    <Resource name="optimized rel plan">
+      <![CDATA[
+LogicalProject(b=[$1])
++- LogicalJoin(condition=[=(CASE(AND(IS NOT TRUE(OR(IS NULL($0), =($4, 0))), IS NOT NULL($8)), 1, 2), $9)], joinType=[inner])
+   :- LogicalJoin(condition=[=($0, $7)], joinType=[left])
+   :  :- LogicalJoin(condition=[=($0, $3)], joinType=[left])
+   :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
+   :  :  +- LogicalAggregate(group=[{0}], c=[COUNT()], ck=[COUNT($1)])
+   :  :     +- LogicalProject(i1=[$0], i=[$0])
+   :  :        +- LogicalFilter(condition=[IS NOT NULL($0)])
+   :  :           +- LogicalTableScan(table=[[default_catalog, default_database, t1]])
+   :  +- LogicalFilter(condition=[=($1, $0)])
+   :     +- LogicalProject(i=[$0], i2=[$1], $f2=[true])
+   :        +- LogicalAggregate(group=[{0, 1}])
+   :           +- LogicalProject(i=[$0], i2=[$0])
+   :              +- LogicalFilter(condition=[IS NOT NULL($0)])
+   :                 +- LogicalTableScan(table=[[default_catalog, default_database, t1]])
+   +- LogicalAggregate(group=[{0}])
+      +- LogicalProject(d=[$0])
+         +- LogicalTableScan(table=[[default_catalog, default_database, r]])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/physical/stream/PushCalcPastChangelogNormalizeRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/physical/stream/PushCalcPastChangelogNormalizeRuleTest.xml
index 646fa9943b4c2..5e89202b442cc 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/physical/stream/PushCalcPastChangelogNormalizeRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/physical/stream/PushCalcPastChangelogNormalizeRuleTest.xml
@@ -67,7 +67,7 @@ GroupAggregate(groupBy=[f0, f1, f2, f3], select=[f0, f1, f2, f3])
       :  +- ChangelogNormalize(key=[f1], condition=[f0 IS NOT NULL])(reuse_id=[1])
       :     +- Exchange(distribution=[hash[f1]])
       :        +- TableSourceScan(table=[[default_catalog, default_database, T]], fields=[f0, f1, f2, f3])
-      +- Join(joinType=[LeftSemiJoin], where=[(((f0 = f00) OR (f0 IS NULL AND f00 IS NULL)) AND (f1 = f10) AND ((f2 = f20) OR (f2 IS NULL AND f20 IS NULL)) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
+      +- Join(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(f0, f00) AND (f1 = f10) AND IS NOT DISTINCT FROM(f2, f20) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
          :- Exchange(distribution=[hash[f0, f1, f2, f3]])
          :  +- Calc(select=[f0, f1, f2, f3], where=[SEARCH(f0, Sarg[(0..2)])])
          :     +- Reused(reference_id=[1])
@@ -106,7 +106,7 @@ GroupAggregate(groupBy=[f0, f1, f2, f3], select=[f0, f1, f2, f3])
       :- ChangelogNormalize(key=[f1], condition=[SEARCH(f3, Sarg[(0..1)])])
       :  +- Exchange(distribution=[hash[f1]])
       :     +- TableSourceScan(table=[[default_catalog, default_database, T]], fields=[f0, f1, f2, f3])
-      +- Join(joinType=[LeftSemiJoin], where=[(((f0 = f00) OR (f0 IS NULL AND f00 IS NULL)) AND (f1 = f10) AND ((f2 = f20) OR (f2 IS NULL AND f20 IS NULL)) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
+      +- Join(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(f0, f00) AND (f1 = f10) AND IS NOT DISTINCT FROM(f2, f20) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
          :- Exchange(distribution=[hash[f0, f1, f2, f3]])
          :  +- ChangelogNormalize(key=[f1], condition=[SEARCH(f3, Sarg[(0..1)])])
          :     +- Exchange(distribution=[hash[f1]])
@@ -148,7 +148,7 @@ GroupAggregate(groupBy=[f0, f1, f2, f3], select=[f0, f1, f2, f3])
       :  +- ChangelogNormalize(key=[f1])(reuse_id=[1])
       :     +- Exchange(distribution=[hash[f1]])
       :        +- TableSourceScan(table=[[default_catalog, default_database, T]], fields=[f0, f1, f2, f3])
-      +- Join(joinType=[LeftSemiJoin], where=[(((f0 = f00) OR (f0 IS NULL AND f00 IS NULL)) AND (f1 = f10) AND ((f2 = f20) OR (f2 IS NULL AND f20 IS NULL)) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
+      +- Join(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(f0, f00) AND (f1 = f10) AND IS NOT DISTINCT FROM(f2, f20) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
          :- Exchange(distribution=[hash[f0, f1, f2, f3]])
          :  +- Calc(select=[f0, f1, f2, f3], where=[(f3 < 3)])
          :     +- Reused(reference_id=[1])
@@ -188,7 +188,7 @@ GroupAggregate(groupBy=[f0, f1, f2, f3], select=[f0, f1, f2, f3])
       :  +- ChangelogNormalize(key=[f1], condition=[(f3 > 0)])(reuse_id=[1])
       :     +- Exchange(distribution=[hash[f1]])
       :        +- TableSourceScan(table=[[default_catalog, default_database, T]], fields=[f0, f1, f2, f3])
-      +- Join(joinType=[LeftSemiJoin], where=[(((f0 = f00) OR (f0 IS NULL AND f00 IS NULL)) AND (f1 = f10) AND ((f2 = f20) OR (f2 IS NULL AND f20 IS NULL)) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
+      +- Join(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(f0, f00) AND (f1 = f10) AND IS NOT DISTINCT FROM(f2, f20) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
          :- Exchange(distribution=[hash[f0, f1, f2, f3]])
          :  +- Calc(select=[f0, f1, f2, f3], where=[(f3 < 3)])
          :     +- Reused(reference_id=[1])
@@ -227,7 +227,7 @@ GroupAggregate(groupBy=[f0, f1, f2, f3], select=[f0, f1, f2, f3])
       :- ChangelogNormalize(key=[f1], condition=[SEARCH(f3, Sarg[(0..1)])])(reuse_id=[1])
       :  +- Exchange(distribution=[hash[f1]])
       :     +- TableSourceScan(table=[[default_catalog, default_database, T]], fields=[f0, f1, f2, f3])
-      +- Join(joinType=[LeftSemiJoin], where=[(((f0 = f00) OR (f0 IS NULL AND f00 IS NULL)) AND (f1 = f10) AND ((f2 = f20) OR (f2 IS NULL AND f20 IS NULL)) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
+      +- Join(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(f0, f00) AND (f1 = f10) AND IS NOT DISTINCT FROM(f2, f20) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
          :- Exchange(distribution=[hash[f0, f1, f2, f3]])(reuse_id=[2])
          :  +- Reused(reference_id=[1])
          +- Reused(reference_id=[2])
@@ -386,7 +386,7 @@ GroupAggregate(groupBy=[f0, f1, f2, f3], select=[f0, f1, f2, f3])
       :  +- Exchange(distribution=[hash[f1]])
       :     +- Calc(select=[f0, f1, f2, f3], where=[SEARCH(f1, Sarg[(0..1)])])
       :        +- TableSourceScan(table=[[default_catalog, default_database, T]], fields=[f0, f1, f2, f3])
-      +- Join(joinType=[LeftSemiJoin], where=[(((f0 = f00) OR (f0 IS NULL AND f00 IS NULL)) AND (f1 = f10) AND ((f2 = f20) OR (f2 IS NULL AND f20 IS NULL)) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
+      +- Join(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(f0, f00) AND (f1 = f10) AND IS NOT DISTINCT FROM(f2, f20) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
          :- Exchange(distribution=[hash[f0, f1, f2, f3]])
          :  +- ChangelogNormalize(key=[f1])
          :     +- Exchange(distribution=[hash[f1]])
@@ -430,7 +430,7 @@ GroupAggregate(groupBy=[f0, f1, f2, f3], select=[f0, f1, f2, f3])
       :  +- ChangelogNormalize(key=[f1])(reuse_id=[1])
       :     +- Exchange(distribution=[hash[f1]])
       :        +- TableSourceScan(table=[[default_catalog, default_database, T]], fields=[f0, f1, f2, f3])
-      +- Join(joinType=[LeftSemiJoin], where=[(((f0 = f00) OR (f0 IS NULL AND f00 IS NULL)) AND (f1 = f10) AND ((f2 = f20) OR (f2 IS NULL AND f20 IS NULL)) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
+      +- Join(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(f0, f00) AND (f1 = f10) AND IS NOT DISTINCT FROM(f2, f20) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
          :- Exchange(distribution=[hash[f0, f1, f2, f3]])
          :  +- Calc(select=[f0, f1, f2, f3], where=[(f1 < 3)])
          :     +- Reused(reference_id=[1])
@@ -470,7 +470,7 @@ GroupAggregate(groupBy=[f0, f1, f2, f3], select=[f0, f1, f2, f3])
       :  +- Exchange(distribution=[hash[f1]])
       :     +- Calc(select=[f0, f1, f2, f3], where=[SEARCH(f1, Sarg[(0..1)])])
       :        +- TableSourceScan(table=[[default_catalog, default_database, T]], fields=[f0, f1, f2, f3])
-      +- Join(joinType=[LeftSemiJoin], where=[(((f0 = f00) OR (f0 IS NULL AND f00 IS NULL)) AND (f1 = f10) AND ((f2 = f20) OR (f2 IS NULL AND f20 IS NULL)) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
+      +- Join(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(f0, f00) AND (f1 = f10) AND IS NOT DISTINCT FROM(f2, f20) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
          :- Exchange(distribution=[hash[f0, f1, f2, f3]])(reuse_id=[2])
          :  +- Reused(reference_id=[1])
          +- Reused(reference_id=[2])
@@ -508,7 +508,7 @@ GroupAggregate(groupBy=[f0, f1, f2, f3], select=[f0, f1, f2, f3])
       :     +- Exchange(distribution=[hash[f1]])
       :        +- Calc(select=[f0, f1, f2, f3], where=[(f1 > 0)])
       :           +- TableSourceScan(table=[[default_catalog, default_database, T]], fields=[f0, f1, f2, f3])
-      +- Join(joinType=[LeftSemiJoin], where=[(((f0 = f00) OR (f0 IS NULL AND f00 IS NULL)) AND (f1 = f10) AND ((f2 = f20) OR (f2 IS NULL AND f20 IS NULL)) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
+      +- Join(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(f0, f00) AND (f1 = f10) AND IS NOT DISTINCT FROM(f2, f20) AND (f3 = f30))], select=[f0, f1, f2, f3], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
          :- Exchange(distribution=[hash[f0, f1, f2, f3]])
          :  +- Calc(select=[f0, f1, f2, f3], where=[(f1 < 3)])
          :     +- Reused(reference_id=[1])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/CalcTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/CalcTest.xml
index b7b97659a739c..87225179619c4 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/CalcTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/CalcTest.xml
@@ -351,7 +351,7 @@ Calc(select=[field1 AS dt])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(EXPR$0=[ROW($0, $1, $2)], EXPR$1=[ARRAY(12, $1)], EXPR$2=[MAP($0, $2)])
-+- LogicalFilter(condition=[AND(=($0, _UTF-16LE'foo'), =($1, 12), =($2, 1984-07-12 14:34:24))])
++- LogicalFilter(condition=[AND(=($0, CAST(_UTF-16LE'foo'):VARCHAR(2147483647) CHARACTER SET "UTF-16LE"), =($1, CAST(12):INTEGER), =($2, CAST(1984-07-12 14:34:24):TIMESTAMP(3)))])
    +- LogicalTableScan(table=[[default_catalog, default_database, MyTable5]])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/SetOperatorsTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/SetOperatorsTest.xml
index 92998e94061ce..847e7f20e7d3b 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/SetOperatorsTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/SetOperatorsTest.xml
@@ -130,7 +130,7 @@ LogicalProject(a=[$0])
 Calc(select=[a])
 +- GroupAggregate(groupBy=[a, b], select=[a, b])
    +- Exchange(distribution=[hash[a, b]])
-      +- Join(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], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
+      +- Join(joinType=[LeftSemiJoin], where=[(IS NOT DISTINCT FROM(a, d) AND IS NOT DISTINCT FROM(b, e))], select=[a, b], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
          :- Exchange(distribution=[hash[a, b]])
          :  +- Calc(select=[a, b])
          :     +- TableSourceScan(table=[[default_catalog, default_database, T1]], fields=[a, b, c])
@@ -255,7 +255,7 @@ LogicalMinus(all=[false])
       <![CDATA[
 GroupAggregate(groupBy=[a, b, c], select=[a, b, c])
 +- Exchange(distribution=[hash[a, b, c]])
-   +- Join(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], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
+   +- Join(joinType=[LeftAntiJoin], where=[(IS NOT DISTINCT FROM(a, a0) AND IS NOT DISTINCT FROM(b, b0) AND IS NOT DISTINCT FROM(c, c0))], select=[a, b, c], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
       :- Exchange(distribution=[hash[a, b, c]])(reuse_id=[1])
       :  +- TableSourceScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c])
       +- Reused(reference_id=[1])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/table/ValuesTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/table/ValuesTest.xml
index 5a2078588d0de..c084b01e93f5b 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/table/ValuesTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/table/ValuesTest.xml
@@ -114,7 +114,7 @@ LogicalUnion(all=[true])
 :  +- LogicalValues(tuples=[[{ 0 }]])
 :- LogicalProject(f0=[CAST(+(ABS(-1), 2)):DOUBLE NOT NULL], f1=[_UTF-16LE'ABC':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[MAP(_UTF-16LE'a':VARCHAR(4) CHARACTER SET "UTF-16LE", CAST(+(ABS(-5), -5)):DOUBLE)])
 :  +- LogicalValues(tuples=[[{ 0 }]])
-:- LogicalProject(f0=[PI], f1=[_UTF-16LE'ABC':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[MAP(_UTF-16LE'abc':VARCHAR(4) CHARACTER SET "UTF-16LE", 3.0E0:DOUBLE)])
+:- LogicalProject(f0=[PI()], f1=[_UTF-16LE'ABC':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[MAP(_UTF-16LE'abc':VARCHAR(4) CHARACTER SET "UTF-16LE", 3.0E0:DOUBLE)])
 :  +- LogicalValues(tuples=[[{ 0 }]])
 :- LogicalProject(f0=[3.1E0:DOUBLE], f1=[_UTF-16LE'DEF':VARCHAR(4) CHARACTER SET "UTF-16LE"], f2=[MAP(_UTF-16LE'abcd':VARCHAR(4) CHARACTER SET "UTF-16LE", 3.0E0:DOUBLE)])
 :  +- LogicalValues(tuples=[[{ 0 }]])
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/expressions/SqlExpressionTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/expressions/SqlExpressionTest.scala
index ac796f529ebc7..2e79381428d13 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/expressions/SqlExpressionTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/expressions/SqlExpressionTest.scala
@@ -194,7 +194,8 @@ class SqlExpressionTest extends ExpressionTestBase {
     testSqlApi("UPPER('string')", "STRING")
     testSqlApi("LOWER('STRING')", "string")
     testSqlApi("POSITION('STR' IN 'STRING')", "1")
-    testSqlApi("TRIM(BOTH ' STRING ')", "STRING")
+    // result of CALCITE-6709
+    testSqlApi("TRIM(BOTH FROM ' STRING ')", "STRING")
     testSqlApi("TRIM(LEADING 'x' FROM 'xxxxSTRINGxxxx')", "STRINGxxxx")
     testSqlApi("TRIM(TRAILING 'x' FROM 'xxxxSTRINGxxxx')", "xxxxSTRING")
     testSqlApi(
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.scala
index 065f5b97c7750..e8e797b984ab5 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.scala
@@ -39,7 +39,7 @@ class SubQueryAntiJoinTest extends SubQueryTestBase {
   @Test
   def testNotInOnWhere_NotSubQuery(): Unit = {
     val sqlQuery = "SELECT * FROM x WHERE a NOT IN (1, 2, 3, 4)"
-    util.verifyRelPlanNotExpected(sqlQuery, "joinType=[anti]")
+    util.verifyRelPlan(sqlQuery)
   }
 
   @Test
@@ -215,9 +215,7 @@ class SubQueryAntiJoinTest extends SubQueryTestBase {
       "(CASE WHEN a NOT IN (SELECT i FROM t1 WHERE l.a = t1.i) THEN 1 ELSE 2 END) " +
       "NOT IN (SELECT d FROM r)"
 
-    // TODO some bugs in SubQueryRemoveRule
-    assertThatExceptionOfType(classOf[RuntimeException])
-      .isThrownBy(() => util.verifyRelPlanNotExpected(sqlQuery, "joinType=[anti]"))
+    util.verifyRelPlan(sqlQuery)
   }
 
   @Test
@@ -734,11 +732,7 @@ class SubQueryAntiJoinTest extends SubQueryTestBase {
       " (CASE WHEN b NOT IN (SELECT m FROM t2) THEN 3 ELSE 4 END)) " +
       "  NOT IN (SELECT d, e FROM r)"
 
-    // TODO some bugs in SubQueryRemoveRule
-    //  the result RelNode (LogicalJoin(condition=[=($1, $11)], joinType=[left]))
-    //  after SubQueryRemoveRule is unexpected
-    assertThatExceptionOfType(classOf[NullPointerException])
-      .isThrownBy(() => util.verifyRelPlanNotExpected(sqlQuery, "joinType=[anti]"))
+    util.verifyRelPlan(sqlQuery)
   }
 
   @Test
@@ -764,9 +758,7 @@ class SubQueryAntiJoinTest extends SubQueryTestBase {
       "       WHEN EXISTS (select i FROM t) THEN 4 ELSE 5 END)) " +
       "  NOT IN (SELECT d, e FROM r)"
 
-    // TODO some bugs in SubQueryRemoveRule
-    assertThatExceptionOfType(classOf[RuntimeException])
-      .isThrownBy(() => util.verifyRelPlanNotExpected(sqlQuery, "joinType=[anti]"))
+    util.verifyRelPlan(sqlQuery)
   }
 
 }
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.scala
index 809ac66c577c2..86fb91d680d6c 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.scala
@@ -39,7 +39,7 @@ class SubQuerySemiJoinTest extends SubQueryTestBase {
   @Test
   def testInOnWhere_NotSubQuery(): Unit = {
     val sqlQuery = "SELECT * FROM l WHERE a IN (1, 2, 3, 4)"
-    util.verifyRelPlanNotExpected(sqlQuery, "joinType=[semi]")
+    util.verifyRelPlan(sqlQuery)
   }
 
   @Test
@@ -210,9 +210,7 @@ class SubQuerySemiJoinTest extends SubQueryTestBase {
     val sqlQuery = "SELECT b FROM l WHERE" +
       " (CASE WHEN a IN (SELECT i FROM t1 WHERE l.a = t1.i) THEN 1 ELSE 2 END) IN (SELECT d FROM r)"
 
-    // TODO some bugs in SubQueryRemoveRule
-    assertThatExceptionOfType(classOf[RuntimeException])
-      .isThrownBy(() => util.verifyRelPlanNotExpected(sqlQuery, "joinType=[semi]"))
+    util.verifyRelPlan(sqlQuery)
   }
 
   @Test
@@ -1676,11 +1674,7 @@ class SubQuerySemiJoinTest extends SubQueryTestBase {
       " (CASE WHEN b IN (SELECT m FROM t2) THEN 3 ELSE 4 END)) " +
       " IN (SELECT d, e FROM r)"
 
-    // TODO some bugs in SubQueryRemoveRule
-    //  the result RelNode (LogicalJoin(condition=[=($1, $8)], joinType=[left]))
-    //  after SubQueryRemoveRule is unexpected
-    assertThatExceptionOfType(classOf[NullPointerException])
-      .isThrownBy(() => util.verifyRelPlanNotExpected(sqlQuery, "joinType=[semi]"))
+    util.verifyRelPlan(sqlQuery)
   }
 
 }
diff --git a/flink-table/pom.xml b/flink-table/pom.xml
index eacd06e2cc1ce..bf42e6ef5e4bf 100644
--- a/flink-table/pom.xml
+++ b/flink-table/pom.xml
@@ -79,7 +79,7 @@ under the License.
 	</dependencyManagement>
 
 	<properties>
-		<calcite.version>1.38.0</calcite.version>
+		<calcite.version>1.39.0</calcite.version>
 		<janino.version>3.1.11</janino.version>
 		<guava.version>33.4.0-jre</guava.version>
 		<quartz.version>2.5.2</quartz.version>

From 1b1dc1c38f783bd8ff49e33811b017879aced120 Mon Sep 17 00:00:00 2001
From: Sergey Nuyanzin <snuyanzin@gmail.com>
Date: Mon, 1 Jun 2026 08:24:39 +0200
Subject: [PATCH 4/5] [FLINK-39828][table] Upgrade Calcite to 1.40.0

---
 flink-formats/flink-protobuf/pom.xml          |    2 +-
 flink-table/flink-sql-parser/pom.xml          |    6 +-
 .../src/main/codegen/templates/Parser.jj      |   23 +-
 .../sql/SqlCollectionTypeNameSpec.java        |  137 ++
 .../parser/validate/FlinkSqlConformance.java  |    5 +
 .../flink-table-calcite-bridge/pom.xml        |    7 +-
 .../org/apache/calcite/rel/core/Join.java     |  368 +++++
 .../java/org/apache/calcite/rex/RexUtil.java  |  192 ++-
 .../apache/calcite/runtime/SqlFunctions.java  |   92 +-
 .../java/org/apache/calcite/sql/SqlCall.java  |  252 ---
 .../java/org/apache/calcite/sql/SqlUtil.java  | 1368 -----------------
 .../calcite/sql/fun/SqlCoalesceFunction.java  |   44 +
 .../sql/validate/SqlValidatorImpl.java        |  174 ++-
 .../calcite/sql2rel/RelDecorrelator.java      |   80 +-
 .../src/main/resources/META-INF/NOTICE        |    4 +-
 .../batch/sql/DynamicFunctionPlanTest.xml     |    9 +-
 .../plan/batch/sql/RemoveShuffleTest.xml      |   54 +-
 .../batch/sql/join/BroadcastHashJoinTest.xml  |   85 +-
 .../batch/sql/join/NestedLoopJoinTest.xml     |   49 +-
 .../batch/sql/join/ShuffledHashJoinTest.xml   |  127 +-
 .../plan/batch/sql/join/SortMergeJoinTest.xml |  127 +-
 .../hints/batch/BroadcastJoinHintTest.xml     |   88 +-
 .../plan/hints/batch/NestLoopJoinHintTest.xml |   88 +-
 .../hints/batch/ShuffleHashJoinHintTest.xml   |   90 +-
 .../hints/batch/ShuffleMergeJoinHintTest.xml  |   90 +-
 .../planner/plan/optimize/ScanReuseTest.xml   |   26 +-
 .../JoinConditionTypeCoerceRuleTest.xml       |    2 +-
 .../logical/SimplifyJoinConditionRuleTest.xml |    2 +-
 ...bqueryCorrelateVariablesValidationTest.xml |    2 +-
 .../planner/plan/stream/sql/join/JoinTest.xml |   86 +-
 .../sql/join/BroadcastHashJoinTest.scala      |    7 +
 .../batch/sql/join/ShuffledHashJoinTest.scala |    7 +
 .../batch/sql/join/SortMergeJoinTest.scala    |    6 +
 .../runtime/batch/table/DecimalITCase.scala   |   20 -
 .../src/main/resources/META-INF/NOTICE        |    4 +-
 flink-table/pom.xml                           |    4 +-
 36 files changed, 1513 insertions(+), 2214 deletions(-)
 create mode 100644 flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlCollectionTypeNameSpec.java
 create mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/core/Join.java
 delete mode 100755 flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlCall.java
 delete mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java

diff --git a/flink-formats/flink-protobuf/pom.xml b/flink-formats/flink-protobuf/pom.xml
index 9ca5eea676287..5e8f9341882bf 100644
--- a/flink-formats/flink-protobuf/pom.xml
+++ b/flink-formats/flink-protobuf/pom.xml
@@ -36,7 +36,7 @@ under the License.
 
 	<properties>
 		<!-- the same with flink-table/pom.xml -->
-		<janino.version>3.1.11</janino.version>
+		<janino.version>3.1.12</janino.version>
 	</properties>
 
 	<dependencies>
diff --git a/flink-table/flink-sql-parser/pom.xml b/flink-table/flink-sql-parser/pom.xml
index 8be0c191ffb04..2c4c37d47bb67 100644
--- a/flink-table/flink-sql-parser/pom.xml
+++ b/flink-table/flink-sql-parser/pom.xml
@@ -68,10 +68,10 @@ under the License.
 			<version>${calcite.version}</version>
 			<exclusions>
 				<!--
-				"mvn dependency:tree" as of Calcite 1.39.0:
+				"mvn dependency:tree" as of Calcite 1.40.0:
 
-				[INFO] +- org.apache.calcite:calcite-core:jar:1.39.0:compile
-				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.39.0:compile
+				[INFO] +- org.apache.calcite:calcite-core:jar:1.40.0:compile
+				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.40.0:compile
 				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.26.0:compile
 				[INFO] |  +- org.apiguardian:apiguardian-api:jar:1.1.2:compile
 				[INFO] |  +- org.checkerframework:checker-qual:jar:3.43.0:compile
diff --git a/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj b/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
index a129d40bafda5..3b03088e25ec1 100644
--- a/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
+++ b/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
@@ -179,6 +179,7 @@ public class ${parser.class} extends SqlAbstractParserImpl
                 final String sql =
                     ((SourceStringReader) reader).getSourceString();
                 parser.setOriginalSql(sql);
+                parser.jj_input_stream.ReInit(reader, 1, 1, sql.length());
             }
           return parser;
         }
@@ -1114,17 +1115,19 @@ SqlNodeList SqlStmtList() :
     SqlNode stmt;
 }
 {
-    stmt = SqlStmt() {
-        stmtList.add(stmt);
-    }
     (
-        <SEMICOLON>
-        [
-            stmt = SqlStmt() {
-                stmtList.add(stmt);
-            }
-        ]
-    )*
+        stmt = SqlStmt() {
+            stmtList.add(stmt);
+        }
+        (
+            <SEMICOLON>
+            [
+                stmt = SqlStmt() {
+                    stmtList.add(stmt);
+                }
+            ]
+        )*
+    )?
     <EOF>
     {
         return new SqlNodeList(stmtList, Span.of(stmtList).pos());
diff --git a/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlCollectionTypeNameSpec.java b/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlCollectionTypeNameSpec.java
new file mode 100644
index 0000000000000..a260a6a730d81
--- /dev/null
+++ b/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlCollectionTypeNameSpec.java
@@ -0,0 +1,137 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql;
+
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.util.Litmus;
+import org.apache.calcite.util.Util;
+
+import java.util.Objects;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * A sql type name specification of collection type.
+ *
+ * <p>The grammar definition in SQL-2011 IWD 9075-2:201?(E) 6.1 &lt;collection type&gt; is as
+ * following:
+ *
+ * <blockquote>
+ *
+ * <pre>
+ * &lt;collection type&gt; ::=
+ *     &lt;array type&gt;
+ *   | &lt;multiset type&gt;
+ *
+ * &lt;array type&gt; ::=
+ *   &lt;data type&gt; ARRAY
+ *   [ &lt;left bracket or trigraph&gt;
+ *     &lt;maximum cardinality&gt;
+ *     &lt;right bracket or trigraph&gt; ]
+ *
+ * &lt;maximum cardinality&gt; ::=
+ *   &lt;unsigned integer&gt;
+ *
+ * &lt;multiset type&gt; ::=
+ *   &lt;data type&gt; MULTISET
+ * </pre>
+ *
+ * </blockquote>
+ *
+ * <p>This class is intended to describe SQL collection type. It can describe either simple
+ * collection type like "int array" or nested collection type like "int array array" or "int array
+ * multiset". For nested collection type, the element type name of this {@code
+ * SqlCollectionTypeNameSpec} is also a {@code SqlCollectionTypeNameSpec}.
+ */
+public class SqlCollectionTypeNameSpec extends SqlTypeNameSpec {
+    private final SqlTypeNameSpec elementTypeName;
+    private final SqlTypeName collectionTypeName;
+
+    /**
+     * Creates a {@code SqlCollectionTypeNameSpec}.
+     *
+     * @param elementTypeName Type of the collection element
+     * @param collectionTypeName Collection type name
+     * @param pos Parser position, must not be null
+     */
+    public SqlCollectionTypeNameSpec(
+            SqlTypeNameSpec elementTypeName, SqlTypeName collectionTypeName, SqlParserPos pos) {
+        super(new SqlIdentifier(collectionTypeName.name(), pos), pos);
+        this.elementTypeName = requireNonNull(elementTypeName, "elementTypeName");
+        this.collectionTypeName = requireNonNull(collectionTypeName, "collectionTypeName");
+    }
+
+    public SqlTypeNameSpec getElementTypeName() {
+        return elementTypeName;
+    }
+
+    @Override
+    public RelDataType deriveType(SqlValidator validator) {
+        // FLINK MODIFICATION BEGIN CALCITE-1466
+        final RelDataType type = elementTypeName.deriveType(validator);
+        // FLINK MODIFICATION END
+        return createCollectionType(type, validator.getTypeFactory());
+    }
+
+    @Override
+    public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+        elementTypeName.unparse(writer, leftPrec, rightPrec);
+        writer.keyword(collectionTypeName.name());
+    }
+
+    @Override
+    public boolean equalsDeep(SqlTypeNameSpec spec, Litmus litmus) {
+        if (!(spec instanceof SqlCollectionTypeNameSpec)) {
+            return litmus.fail("{} != {}", this, spec);
+        }
+        SqlCollectionTypeNameSpec that = (SqlCollectionTypeNameSpec) spec;
+        if (!this.elementTypeName.equalsDeep(that.elementTypeName, litmus)) {
+            return litmus.fail("{} != {}", this, spec);
+        }
+        if (!Objects.equals(this.collectionTypeName, that.collectionTypeName)) {
+            return litmus.fail("{} != {}", this, spec);
+        }
+        return litmus.succeed();
+    }
+
+    // ~ Tools ------------------------------------------------------------------
+
+    /**
+     * Create collection data type.
+     *
+     * @param elementType Type of the collection element
+     * @param typeFactory Type factory
+     * @return The collection data type, or throw exception if the collection type name does not
+     *     belong to {@code SqlTypeName} enumerations
+     */
+    private RelDataType createCollectionType(
+            RelDataType elementType, RelDataTypeFactory typeFactory) {
+        switch (collectionTypeName) {
+            case MULTISET:
+                return typeFactory.createMultisetType(elementType, -1);
+            case ARRAY:
+                return typeFactory.createArrayType(elementType, -1);
+
+            default:
+                throw Util.unexpected(collectionTypeName);
+        }
+    }
+}
diff --git a/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java b/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
index 696cdd5edcdae..0524581f2a39e 100644
--- a/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
+++ b/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
@@ -42,6 +42,11 @@ public boolean isGroupByAlias() {
         return false;
     }
 
+    @Override
+    public SelectAliasLookup isSelectAlias() {
+        return SqlConformanceEnum.DEFAULT.isSelectAlias();
+    }
+
     @Override
     public boolean isGroupByOrdinal() {
         return false;
diff --git a/flink-table/flink-table-calcite-bridge/pom.xml b/flink-table/flink-table-calcite-bridge/pom.xml
index 766524641010f..90ade1deb93c9 100644
--- a/flink-table/flink-table-calcite-bridge/pom.xml
+++ b/flink-table/flink-table-calcite-bridge/pom.xml
@@ -45,9 +45,10 @@ under the License.
 			<version>${calcite.version}</version>
 			<exclusions>
 				<!--
-				"mvn dependency:tree" as of Calcite 1.39.0:
-				[INFO] +- org.apache.calcite:calcite-core:jar:1.39.0:compile
-				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.39.0:compile
+				"mvn dependency:tree" as of Calcite 1.40.0:
+				[INFO] org.apache.flink:flink-table-calcite-bridge:jar:2.4-SNAPSHOT
+				[INFO] +- org.apache.calcite:calcite-core:jar:1.40.0:compile
+				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.40.0:compile
 				[INFO] |  +- org.locationtech.jts:jts-core:jar:1.19.0:compile
 				[INFO] |  +- com.fasterxml.jackson.core:jackson-annotations:jar:2.21:compile
 				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.26.0:compile
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/core/Join.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/core/Join.java
new file mode 100644
index 0000000000000..12651a675e688
--- /dev/null
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/core/Join.java
@@ -0,0 +1,368 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.rel.core;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptCost;
+import org.apache.calcite.plan.RelOptPlanner;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.BiRel;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.RelWriter;
+import org.apache.calcite.rel.hint.Hintable;
+import org.apache.calcite.rel.hint.RelHint;
+import org.apache.calcite.rel.metadata.RelMdUtil;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rex.RexChecker;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexShuttle;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.validate.SqlValidatorUtil;
+import org.apache.calcite.util.Litmus;
+import org.apache.calcite.util.Util;
+import org.apiguardian.api.API;
+import org.checkerframework.checker.nullness.qual.EnsuresNonNullIf;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Relational expression that combines two relational expressions according to some condition.
+ *
+ * <p>Each output row has columns from the left and right inputs. The set of output rows is a subset
+ * of the cartesian product of the two inputs; precisely which subset depends on the join condition.
+ */
+public abstract class Join extends BiRel implements Hintable {
+    // ~ Instance fields --------------------------------------------------------
+
+    protected final RexNode condition;
+    protected final ImmutableSet<CorrelationId> variablesSet;
+    protected final ImmutableList<RelHint> hints;
+
+    /**
+     * Values must be of enumeration {@link JoinRelType}, except that {@link JoinRelType#RIGHT} is
+     * disallowed.
+     */
+    protected final JoinRelType joinType;
+
+    protected final JoinInfo joinInfo;
+
+    // ~ Constructors -----------------------------------------------------------
+
+    /**
+     * Creates a Join.
+     *
+     * @param cluster Cluster
+     * @param traitSet Trait set
+     * @param hints Hints
+     * @param left Left input
+     * @param right Right input
+     * @param condition Join condition
+     * @param joinType Join type
+     * @param variablesSet variables that are set by the LHS and used by the RHS and are not
+     *     available to nodes above this Join in the tree
+     */
+    protected Join(
+            RelOptCluster cluster,
+            RelTraitSet traitSet,
+            List<RelHint> hints,
+            RelNode left,
+            RelNode right,
+            RexNode condition,
+            Set<CorrelationId> variablesSet,
+            JoinRelType joinType) {
+        super(cluster, traitSet, left, right);
+        this.condition = requireNonNull(condition, "condition");
+        this.variablesSet = ImmutableSet.copyOf(variablesSet);
+        this.joinType = requireNonNull(joinType, "joinType");
+        // FLINK MODIFICATION BEGIN CALCITE-7327, CALCITE-6904
+        this.joinInfo = JoinInfo.of(left, right, condition);
+        // FLINK MODIFICATION END
+        this.hints = ImmutableList.copyOf(hints);
+    }
+
+    @Deprecated // to be removed before 2.0
+    protected Join(
+            RelOptCluster cluster,
+            RelTraitSet traitSet,
+            RelNode left,
+            RelNode right,
+            RexNode condition,
+            Set<CorrelationId> variablesSet,
+            JoinRelType joinType) {
+        this(cluster, traitSet, ImmutableList.of(), left, right, condition, variablesSet, joinType);
+    }
+
+    @Deprecated // to be removed before 2.0
+    protected Join(
+            RelOptCluster cluster,
+            RelTraitSet traitSet,
+            RelNode left,
+            RelNode right,
+            RexNode condition,
+            JoinRelType joinType,
+            Set<String> variablesStopped) {
+        this(
+                cluster,
+                traitSet,
+                ImmutableList.of(),
+                left,
+                right,
+                condition,
+                CorrelationId.setOf(variablesStopped),
+                joinType);
+    }
+
+    // ~ Methods ----------------------------------------------------------------
+
+    @Override
+    public RelNode accept(RexShuttle shuttle) {
+        RexNode condition = shuttle.apply(this.condition);
+        if (this.condition == condition) {
+            return this;
+        }
+        return copy(traitSet, condition, left, right, joinType, isSemiJoinDone());
+    }
+
+    public RexNode getCondition() {
+        return condition;
+    }
+
+    public JoinRelType getJoinType() {
+        return joinType;
+    }
+
+    @Override
+    public boolean isValid(Litmus litmus, @Nullable Context context) {
+        if (!super.isValid(litmus, context)) {
+            return false;
+        }
+        if (getRowType().getFieldCount()
+                != getSystemFieldList().size()
+                        + left.getRowType().getFieldCount()
+                        + (joinType.projectsRight() ? right.getRowType().getFieldCount() : 0)) {
+            return litmus.fail("field count mismatch");
+        }
+        if (condition != null) {
+            if (condition.getType().getSqlTypeName() != SqlTypeName.BOOLEAN) {
+                return litmus.fail("condition must be boolean: {}", condition.getType());
+            }
+            // The input to the condition is a row type consisting of system
+            // fields, left fields, and right fields. Very similar to the
+            // output row type, except that fields have not yet been made due
+            // due to outer joins.
+            RexChecker checker =
+                    new RexChecker(
+                            getCluster()
+                                    .getTypeFactory()
+                                    .builder()
+                                    .addAll(getSystemFieldList())
+                                    .addAll(getLeft().getRowType().getFieldList())
+                                    .addAll(getRight().getRowType().getFieldList())
+                                    .build(),
+                            context,
+                            litmus);
+            condition.accept(checker);
+            if (checker.getFailureCount() > 0) {
+                return litmus.fail(
+                        checker.getFailureCount() + " failures in condition " + condition);
+            }
+        }
+        return litmus.succeed();
+    }
+
+    @Override
+    public @Nullable RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) {
+        // Maybe we should remove this for semi-join?
+        if (isSemiJoin()) {
+            // REVIEW jvs 9-Apr-2006:  Just for now...
+            return planner.getCostFactory().makeTinyCost();
+        }
+        double rowCount = mq.getRowCount(this);
+        return planner.getCostFactory().makeCost(rowCount, 0, 0);
+    }
+
+    // CHECKSTYLE: IGNORE 1
+    /**
+     * @deprecated Use {@link RelMdUtil#getJoinRowCount(RelMetadataQuery, Join, RexNode)}.
+     */
+    @Deprecated // to be removed before 2.0
+    public static double estimateJoinedRows(Join joinRel, RexNode condition) {
+        final RelMetadataQuery mq = joinRel.getCluster().getMetadataQuery();
+        return Util.first(RelMdUtil.getJoinRowCount(mq, joinRel, condition), 1D);
+    }
+
+    @Override
+    public double estimateRowCount(RelMetadataQuery mq) {
+        return Util.first(RelMdUtil.getJoinRowCount(mq, this, condition), 1D);
+    }
+
+    @Override
+    public Set<CorrelationId> getVariablesSet() {
+        return variablesSet;
+    }
+
+    @Override
+    public RelWriter explainTerms(RelWriter pw) {
+        return super.explainTerms(pw)
+                .item("condition", condition)
+                .item("joinType", joinType.lowerName)
+                .itemIf("variablesSet", variablesSet, !variablesSet.isEmpty())
+                .itemIf("systemFields", getSystemFieldList(), !getSystemFieldList().isEmpty());
+    }
+
+    @API(since = "1.24", status = API.Status.INTERNAL)
+    @EnsuresNonNullIf(expression = "#1", result = true)
+    protected boolean deepEquals0(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+        Join o = (Join) obj;
+        return traitSet.equals(o.traitSet)
+                && left.deepEquals(o.left)
+                && right.deepEquals(o.right)
+                && condition.equals(o.condition)
+                && joinType == o.joinType
+                && hints.equals(o.hints)
+                && getRowType().equalsSansFieldNames(o.getRowType());
+    }
+
+    @API(since = "1.24", status = API.Status.INTERNAL)
+    protected int deepHashCode0() {
+        return Objects.hash(
+                traitSet, left.deepHashCode(), right.deepHashCode(), condition, joinType, hints);
+    }
+
+    @Override
+    protected RelDataType deriveRowType() {
+        return SqlValidatorUtil.deriveJoinRowType(
+                left.getRowType(),
+                right.getRowType(),
+                joinType,
+                getCluster().getTypeFactory(),
+                null,
+                getSystemFieldList());
+    }
+
+    /**
+     * Returns whether this LogicalJoin has already spawned a {@code SemiJoin} via {@link
+     * org.apache.calcite.rel.rules.JoinAddRedundantSemiJoinRule}.
+     *
+     * <p>The base implementation returns false.
+     *
+     * @return whether this join has already spawned a semi join
+     */
+    public boolean isSemiJoinDone() {
+        return false;
+    }
+
+    /**
+     * Returns whether this Join is a semijoin.
+     *
+     * @return true if this Join's join type is semi.
+     */
+    public boolean isSemiJoin() {
+        return joinType == JoinRelType.SEMI;
+    }
+
+    /**
+     * Returns a list of system fields that will be prefixed to output row type.
+     *
+     * @return list of system fields
+     */
+    public List<RelDataTypeField> getSystemFieldList() {
+        return Collections.emptyList();
+    }
+
+    @Deprecated // to be removed before 2.0
+    public static RelDataType deriveJoinRowType(
+            RelDataType leftType,
+            RelDataType rightType,
+            JoinRelType joinType,
+            RelDataTypeFactory typeFactory,
+            @Nullable List<String> fieldNameList,
+            List<RelDataTypeField> systemFieldList) {
+        return SqlValidatorUtil.deriveJoinRowType(
+                leftType, rightType, joinType, typeFactory, fieldNameList, systemFieldList);
+    }
+
+    @Deprecated // to be removed before 2.0
+    public static RelDataType createJoinType(
+            RelDataTypeFactory typeFactory,
+            RelDataType leftType,
+            RelDataType rightType,
+            List<String> fieldNameList,
+            List<RelDataTypeField> systemFieldList) {
+        return SqlValidatorUtil.createJoinType(
+                typeFactory, leftType, rightType, fieldNameList, systemFieldList);
+    }
+
+    @Override
+    public Join copy(RelTraitSet traitSet, List<RelNode> inputs) {
+        assert inputs.size() == 2;
+        return copy(
+                traitSet, getCondition(), inputs.get(0), inputs.get(1), joinType, isSemiJoinDone());
+    }
+
+    /**
+     * Creates a copy of this join, overriding condition, system fields and inputs.
+     *
+     * <p>General contract as {@link RelNode#copy}.
+     *
+     * @param traitSet Traits
+     * @param conditionExpr Condition
+     * @param left Left input
+     * @param right Right input
+     * @param joinType Join type
+     * @param semiJoinDone Whether this join has been translated to a semi-join
+     * @return Copy of this join
+     */
+    public abstract Join copy(
+            RelTraitSet traitSet,
+            RexNode conditionExpr,
+            RelNode left,
+            RelNode right,
+            JoinRelType joinType,
+            boolean semiJoinDone);
+
+    /**
+     * Analyzes the join condition.
+     *
+     * @return Analyzed join condition
+     */
+    public JoinInfo analyzeCondition() {
+        return joinInfo;
+    }
+
+    @Override
+    public ImmutableList<RelHint> getHints() {
+        return hints;
+    }
+}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
index 1ccd4a6217174..65e905b367472 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
@@ -47,6 +47,7 @@
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
+import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.util.ControlFlowException;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.Litmus;
@@ -80,10 +81,7 @@
  * because of current Calcite way of inferring constants from IS NOT DISTINCT FROM clashes with
  * filter push down.
  *
- * <p>Lines 402 ~ 404, Use Calcite 1.32.0 behavior for {@link RexUtil#gatherConstraints(Class,
- * RexNode, Map, Set, RexBuilder)}.
- *
- * <p>FLINK modifications (backport of CALCITE-6764): Line 2481~2485
+ * <p>FLINK modifications (backport of CALCITE-6764): Line 2489~2494
  */
 public class RexUtil {
 
@@ -401,9 +399,7 @@ private static <C extends RexNode> void gatherConstraints(
         final RexNode right;
         switch (predicate.getKind()) {
             case EQUALS:
-                // FLINK BEGIN MODIFICATION
-                // case IS_NOT_DISTINCT_FROM:
-                // FLINK END MODIFICATION
+            case IS_NOT_DISTINCT_FROM:
                 left = ((RexCall) predicate).getOperands().get(0);
                 right = ((RexCall) predicate).getOperands().get(1);
                 break;
@@ -2591,7 +2587,7 @@ public RexNode toCnf(RexNode rex) {
             try {
                 this.currentCount = 0;
                 return toCnf2(rex);
-            } catch (OverflowError e) {
+            } catch (PlanTooComplexError e) {
                 Util.swallow(e, null);
                 return rex;
             }
@@ -2658,19 +2654,10 @@ private RexNode toCnf2(RexNode rex) {
 
         private void incrementAndCheck() {
             if (maxNodeCount >= 0 && ++currentCount > maxNodeCount) {
-                throw OverflowError.INSTANCE;
+                throw new PlanTooComplexError();
             }
         }
 
-        /** Exception to catch when we pass the limit. */
-        @SuppressWarnings("serial")
-        private static class OverflowError extends ControlFlowException {
-            @SuppressWarnings("ThrowableInstanceNeverThrown")
-            protected static final OverflowError INSTANCE = new OverflowError();
-
-            private OverflowError() {}
-        }
-
         private RexNode pull(RexNode rex) {
             final List<RexNode> operands;
             switch (rex.getKind()) {
@@ -2820,6 +2807,169 @@ private RexNode or(Iterable<? extends RexNode> nodes) {
         }
     }
 
+    /**
+     * Helper class that expands predicates from disjunctions (split by K).
+     *
+     * @param <K> The dimension used to split predicates in disjunctions. If you want to expand
+     *     predicates that can be pushed down to a single table from the disjunction, K is {@link
+     *     RelTableRef}; if you want to expand predicates that can be pushed down to Join inputs
+     *     from the disjunction, K is string whose value is 'left' or 'right'.
+     */
+    public abstract static class ExpandDisjunctionHelper<K> {
+        private final RelBuilder relBuilder;
+
+        private final int maxNodeCount;
+
+        // Used to record the number of redundant expressions expanded.
+        private int expressionIncreaseAmount;
+
+        public ExpandDisjunctionHelper(RelBuilder relBuilder, int maxNodeCount) {
+            this.relBuilder = relBuilder;
+            this.maxNodeCount = maxNodeCount;
+        }
+
+        public Map<K, RexNode> expand(RexNode condition) {
+            try {
+                this.expressionIncreaseAmount = 0;
+                return expandDeep(condition);
+            } catch (PlanTooComplexError e) {
+                return new HashMap<>();
+            }
+        }
+
+        /**
+         * Expand predicates recursively that can be pushed down to a single K. As mentioned above,
+         * K is the dimension used to split predicates in disjunctions, which can be {@link
+         * RelTableRef} or string whose value is 'left' or 'right'.
+         *
+         * @param condition Predicate to be expanded
+         * @return A map from a K to a (combined) predicate that can be pushed down and only depends
+         *     on columns of K.
+         */
+        private Map<K, RexNode> expandDeep(RexNode condition) {
+            final Map<K, RexNode> additionalConditions = new HashMap<>();
+
+            if (canReturnEarly(condition, additionalConditions)) {
+                return additionalConditions;
+            }
+
+            // Recursively expand the expression according to whether it is a conjunction
+            // or a disjunction. If it is neither a disjunction nor a conjunction, it cannot
+            // be expanded further and an empty Map is returned.
+            switch (condition.getKind()) {
+                case AND:
+                    List<RexNode> andOperands =
+                            RexUtil.flattenAnd(((RexCall) condition).getOperands());
+                    for (RexNode andOperand : andOperands) {
+                        Map<K, RexNode> operandResult = expandDeep(andOperand);
+                        combinePredicatesUsingAnd(additionalConditions, operandResult);
+                    }
+                    break;
+                case OR:
+                    List<RexNode> orOperands =
+                            RexUtil.flattenOr(((RexCall) condition).getOperands());
+                    additionalConditions.putAll(expandDeep(orOperands.get(0)));
+                    for (int i = 1; i < orOperands.size(); i++) {
+                        Map<K, RexNode> operandResult = expandDeep(orOperands.get(i));
+                        combinePredicatesUsingOr(additionalConditions, operandResult);
+
+                        if (additionalConditions.isEmpty()) {
+                            break;
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+
+            return additionalConditions;
+        }
+
+        // If condition already belongs to a certain K, return early.
+        protected abstract boolean canReturnEarly(
+                RexNode condition, Map<K, RexNode> additionalConditions);
+
+        /**
+         * Combine predicates that depend on the same K using conjunctions. The result is returned
+         * by modifying baseMap. For example:
+         *
+         * <p>baseMap: {k1: p1, k2: p2}
+         *
+         * <p>forMergeMap: {k1: p11, k3: p3}
+         *
+         * <p>result: {k1: p1 AND p11, k2: p2, k3: p3}
+         *
+         * @param baseMap Additional predicates that current conjunction has already saved
+         * @param forMergeMap Additional predicates that current operand has expanded
+         */
+        private void combinePredicatesUsingAnd(
+                Map<K, RexNode> baseMap, Map<K, RexNode> forMergeMap) {
+            for (Map.Entry<K, RexNode> entry : forMergeMap.entrySet()) {
+                RexNode mergedRex =
+                        relBuilder.and(
+                                entry.getValue(),
+                                baseMap.getOrDefault(entry.getKey(), relBuilder.literal(true)));
+                int originalCount =
+                        entry.getValue().nodeCount()
+                                + (baseMap.containsKey(entry.getKey())
+                                        ? baseMap.get(entry.getKey()).nodeCount()
+                                        : 0);
+                checkExpandCount(mergedRex.nodeCount() - originalCount);
+                baseMap.put(entry.getKey(), mergedRex);
+            }
+        }
+
+        /**
+         * Combine predicates that depend on the same K using disjunctions. The result is returned
+         * by modifying baseMap. For example:
+         *
+         * <p>baseMap: {k1: p1, k2: p2}
+         *
+         * <p>forMergeMap: {k1: p11, k3: p3}
+         *
+         * <p>result: {k1: p1 OR p11}
+         *
+         * @param baseMap Additional predicates that current disjunction has already saved
+         * @param forMergeMap Additional predicates that current operand has expanded
+         */
+        private void combinePredicatesUsingOr(
+                Map<K, RexNode> baseMap, Map<K, RexNode> forMergeMap) {
+            if (baseMap.isEmpty()) {
+                return;
+            }
+
+            Iterator<Map.Entry<K, RexNode>> iterator = baseMap.entrySet().iterator();
+            while (iterator.hasNext()) {
+                int forMergeNodeCount = 0;
+
+                Map.Entry<K, RexNode> entry = iterator.next();
+                if (!forMergeMap.containsKey(entry.getKey())) {
+                    checkExpandCount(-entry.getValue().nodeCount());
+                    iterator.remove();
+                    continue;
+                } else {
+                    forMergeNodeCount = forMergeMap.get(entry.getKey()).nodeCount();
+                }
+                RexNode mergedRex =
+                        relBuilder.or(entry.getValue(), forMergeMap.get(entry.getKey()));
+                int originalCount = entry.getValue().nodeCount() + forMergeNodeCount;
+                checkExpandCount(mergedRex.nodeCount() - originalCount);
+                baseMap.put(entry.getKey(), mergedRex);
+            }
+        }
+
+        /**
+         * Check whether the number of redundant expressions generated in the expansion exceeds the
+         * limit.
+         */
+        protected void checkExpandCount(int changeCount) {
+            expressionIncreaseAmount += changeCount;
+            if (maxNodeCount > 0 && expressionIncreaseAmount > maxNodeCount) {
+                throw new PlanTooComplexError();
+            }
+        }
+    }
+
     /** Shuttle that adds {@code offset} to each {@link RexInputRef} in an expression. */
     private static class RexShiftShuttle extends RexShuttle {
         private final int offset;
@@ -2834,6 +2984,12 @@ public RexNode visitInputRef(RexInputRef input) {
         }
     }
 
+    /**
+     * Exception to catch when optimizing the plan produces a result that is too complex, either at
+     * the Rel or at the Rex level.
+     */
+    private static class PlanTooComplexError extends ControlFlowException {}
+
     /**
      * Visitor that throws {@link org.apache.calcite.util.Util.FoundOne} if applied to an expression
      * that contains a {@link RexCorrelVariable}.
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
index 232b86c58b05a..e5a41b36323ca 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
@@ -102,6 +102,7 @@
 import java.time.format.DateTimeParseException;
 import java.time.format.SignStyle;
 import java.time.temporal.ChronoField;
+import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Base64;
@@ -112,6 +113,7 @@
 import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
@@ -776,7 +778,7 @@ public String regexpReplace(
                 int pos,
                 int occurrence,
                 @Nullable String matchType) {
-            if (pos < 1 || pos > s.length()) {
+            if (pos < 1 || pos > s.length() + 1) {
                 throw RESOURCE.invalidInputForRegexpReplace(Integer.toString(pos)).ex();
             }
 
@@ -788,7 +790,7 @@ public String regexpReplace(
 
         /** SQL {@code REGEXP_REPLACE} function for PostgreSQL with 3 arguments. */
         public String regexpReplacePg(String s, String regex, String replacement) {
-            return regexpReplace(s, regex, replacement, 1, 1, null);
+            return regexpReplaceNonDollarIndexed(s, regex, replacement, 1, 1, null);
         }
 
         /** SQL {@code REGEXP_REPLACE} function for PostgreSQL with 4 arguments. */
@@ -796,7 +798,7 @@ public String regexpReplacePg(
                 String s, String regex, String replacement, String matchType) {
             // Translate g flag to occurrence
             final int occurrence = matchType.contains("g") ? 0 : 1;
-            return regexpReplace(s, regex, replacement, 1, occurrence, matchType);
+            return regexpReplaceNonDollarIndexed(s, regex, replacement, 1, occurrence, matchType);
         }
 
         /**
@@ -804,6 +806,16 @@ public String regexpReplacePg(
          * capturing groups.
          */
         public String regexpReplaceNonDollarIndexed(String s, String regex, String replacement) {
+            return regexpReplaceNonDollarIndexed(s, regex, replacement, 1, 0, null);
+        }
+
+        private String regexpReplaceNonDollarIndexed(
+                String s,
+                String regex,
+                String replacement,
+                int pos,
+                int occurrence,
+                @Nullable String matchType) {
             // Modify double-backslash capturing group indices in replacement argument,
             // retrieved from cache when available.
             String indexedReplacement;
@@ -817,7 +829,7 @@ public String regexpReplaceNonDollarIndexed(String s, String regex, String repla
             }
 
             // Call generic regexp replace method with modified replacement pattern
-            return regexpReplace(s, regex, indexedReplacement, 1, 0, null);
+            return regexpReplace(s, regex, indexedReplacement, pos, occurrence, matchType);
         }
 
         private static int makeRegexpFlags(String stringFlags) {
@@ -6274,6 +6286,44 @@ public static List arrayUnion(List list1, List list2) {
         return new ArrayList<>(result);
     }
 
+    /** Transforms a list, applying a function to each element. */
+    public static <F, T> List<T> transform(
+            List<? extends F> list, Function1<? super F, ? extends T> function) {
+        return new TransformingList<>(list, function);
+    }
+
+    /**
+     * List that returns the same number of elements as a backing list, applying a transformation
+     * function to each one.
+     *
+     * @param <F> Element type of backing list
+     * @param <T> Element type of this list
+     */
+    private static class TransformingList<F, T> extends AbstractList<T> {
+        private final Function1<? super F, ? extends T> function;
+        private final List<? extends F> list;
+
+        TransformingList(List<? extends F> list, Function1<? super F, ? extends T> function) {
+            this.function = function;
+            this.list = list;
+        }
+
+        @Override
+        public T get(int i) {
+            return function.apply(list.get(i));
+        }
+
+        @Override
+        public int size() {
+            return list.size();
+        }
+
+        @Override
+        public Iterator<T> iterator() {
+            return listIterator();
+        }
+    }
+
     /** Support the SORT_ARRAY function. */
     public static List sortArray(List list, boolean ascending) {
         Comparator comparator =
@@ -6612,6 +6662,40 @@ public static String arrayToString(List list, String delimiter, @Nullable String
         return sb.toString();
     }
 
+    /**
+     * SQL {@code STRING_TO_ARRAY(string, delimiter)} function. Returns a one-dimensional string[]
+     * array by splitting the input string value into subvalues using the specified string value as
+     * the "delimiter". Optionally, allows a specified string value to be interpreted as NULL.
+     */
+    public static List<String> stringToArray(String string, @Nullable String delimiter) {
+        return stringToArray(string, delimiter, null);
+    }
+
+    /** SQL {@code STRING_TO_ARRAY(string, delimiter, nullString)} function. */
+    public static List<String> stringToArray(
+            String string, @Nullable String delimiter, @Nullable String nullString) {
+        String[] parts;
+        if (delimiter == null) {
+            parts =
+                    string.chars()
+                            .mapToObj(c -> Character.toString((char) c))
+                            .toArray(String[]::new);
+        } else if (delimiter.isEmpty()) {
+            parts = new String[] {string};
+        } else {
+            parts = string.split(delimiter);
+        }
+        List<String> result = new ArrayList<>(parts.length);
+        for (String part : parts) {
+            if (nullString != null && nullString.equals(part)) {
+                result.add(null);
+            } else {
+                result.add(part);
+            }
+        }
+        return result;
+    }
+
     /**
      * Function that, given a certain List containing single-item structs (i.e. arrays / lists with
      * a single item), builds an Enumerable that returns those single items inside the structs.
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlCall.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlCall.java
deleted file mode 100755
index 9e1471376d09a..0000000000000
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlCall.java
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.sql;
-
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.util.SqlVisitor;
-import org.apache.calcite.sql.validate.SqlMoniker;
-import org.apache.calcite.sql.validate.SqlMonotonicity;
-import org.apache.calcite.sql.validate.SqlValidator;
-import org.apache.calcite.sql.validate.SqlValidatorImpl;
-import org.apache.calcite.sql.validate.SqlValidatorScope;
-import org.apache.calcite.util.Litmus;
-import org.checkerframework.checker.nullness.qual.Nullable;
-import org.checkerframework.dataflow.qual.Pure;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Objects;
-
-import static org.apache.calcite.linq4j.Nullness.castNonNull;
-
-/**
- * A <code>SqlCall</code> is a call to an {@link SqlOperator operator}. (Operators can be used to
- * describe any syntactic construct, so in practice, every non-leaf node in a SQL parse tree is a
- * <code>SqlCall</code> of some kind.)
- *
- * <p>FLINK modifications are at lines
- *
- * <ol>
- *   <li>Should be removed after fixing CALCITE-6944 (Calcite 1.40.0): Lines 121-139
- * </ol>
- */
-public abstract class SqlCall extends SqlNode {
-    // ~ Constructors -----------------------------------------------------------
-
-    protected SqlCall(SqlParserPos pos) {
-        super(pos);
-    }
-
-    // ~ Methods ----------------------------------------------------------------
-
-    /**
-     * Whether this call was created by expanding a parentheses-free call to what was syntactically
-     * an identifier.
-     */
-    public boolean isExpanded() {
-        return false;
-    }
-
-    /**
-     * Changes the value of an operand. Allows some rewrite by {@link SqlValidator}; use sparingly.
-     *
-     * @param i Operand index
-     * @param operand Operand value
-     */
-    public void setOperand(int i, @Nullable SqlNode operand) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public SqlKind getKind() {
-        return getOperator().getKind();
-    }
-
-    @Pure
-    public abstract SqlOperator getOperator();
-
-    /**
-     * Returns the list of operands. The set and order of operands is call-specific.
-     *
-     * <p>Note: the proper type would be {@code List<@Nullable SqlNode>}, however, it would trigger
-     * too many changes to the current codebase.
-     *
-     * @return the list of call operands, never null, the operands can be null
-     */
-    public abstract List</*Nullable*/ SqlNode> getOperandList();
-
-    /**
-     * Returns i-th operand (0-based).
-     *
-     * <p>Note: the result might be null, so the proper signature would be {@code <S
-     * extends @Nullable SqlNode>}, however, it would trigger to many changes to the current
-     * codebase.
-     *
-     * @param i operand index (0-based)
-     * @param <S> type of the result
-     * @return i-th operand (0-based), the result might be null
-     */
-    @SuppressWarnings("unchecked")
-    public <S extends /*Nullable*/ SqlNode> S operand(int i) {
-        // Note: in general, null elements exist in the list, however, the code
-        // assumes operand(..) is non-nullable, so we add a cast here
-        return (S) castNonNull(getOperandList().get(i));
-    }
-
-    public int operandCount() {
-        return getOperandList().size();
-    }
-
-    @Override
-    public SqlNode clone(SqlParserPos pos) {
-        return getOperator().createCall(getFunctionQuantifier(), pos, getOperandList());
-    }
-
-    // FLINK MODIFICATION BEGIN
-    private boolean needsParentheses(SqlWriter writer, int leftPrec, int rightPrec) {
-        if (getKind() == SqlKind.SET_SEMANTICS_TABLE) {
-            return false;
-        }
-        final SqlOperator operator = getOperator();
-        return leftPrec > operator.getLeftPrec()
-                || (operator.getRightPrec() <= rightPrec && (rightPrec != 0))
-                || writer.isAlwaysUseParentheses() && isA(SqlKind.EXPRESSION);
-    }
-
-    @Override
-    public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
-        final SqlDialect dialect = writer.getDialect();
-        if (needsParentheses(writer, leftPrec, rightPrec)) {
-            final SqlWriter.Frame frame = writer.startList("(", ")");
-            dialect.unparseCall(writer, this, 0, 0);
-            writer.endList(frame);
-            // FLINK MODIFICATION END
-        } else {
-            dialect.unparseCall(writer, this, leftPrec, rightPrec);
-        }
-    }
-
-    /**
-     * Validates this call.
-     *
-     * <p>The default implementation delegates the validation to the operator's {@link
-     * SqlOperator#validateCall}. Derived classes may override (as do, for example {@link SqlSelect}
-     * and {@link SqlUpdate}).
-     */
-    @Override
-    public void validate(SqlValidator validator, SqlValidatorScope scope) {
-        validator.validateCall(this, scope);
-    }
-
-    @Override
-    public void findValidOptions(
-            SqlValidator validator,
-            SqlValidatorScope scope,
-            SqlParserPos pos,
-            Collection<SqlMoniker> hintList) {
-        for (SqlNode operand : getOperandList()) {
-            if (operand instanceof SqlIdentifier) {
-                SqlIdentifier id = (SqlIdentifier) operand;
-                SqlParserPos idPos = id.getParserPosition();
-                if (idPos.toString().equals(pos.toString())) {
-                    ((SqlValidatorImpl) validator)
-                            .lookupNameCompletionHints(scope, id.names, pos, hintList);
-                    return;
-                }
-            }
-        }
-        // no valid options
-    }
-
-    @Override
-    public <R> R accept(SqlVisitor<R> visitor) {
-        return visitor.visit(this);
-    }
-
-    @Override
-    public boolean equalsDeep(@Nullable SqlNode node, Litmus litmus) {
-        if (node == this) {
-            return true;
-        }
-        if (!(node instanceof SqlCall)) {
-            return litmus.fail("{} != {}", this, node);
-        }
-        SqlCall that = (SqlCall) node;
-
-        // Compare operators by name, not identity, because they may not
-        // have been resolved yet. Use case insensitive comparison since
-        // this may be a case insensitive system.
-        if (!this.getOperator().getName().equalsIgnoreCase(that.getOperator().getName())) {
-            return litmus.fail("{} != {}", this, node);
-        }
-        if (!equalDeep(this.getFunctionQuantifier(), that.getFunctionQuantifier(), litmus)) {
-            return litmus.fail("{} != {} (function quantifier differs)", this, node);
-        }
-        return equalDeep(this.getOperandList(), that.getOperandList(), litmus);
-    }
-
-    /**
-     * Returns a string describing the actual argument types of a call, e.g. "SUBSTR(VARCHAR(12),
-     * NUMBER(3,2), INTEGER)".
-     */
-    public String getCallSignature(SqlValidator validator, @Nullable SqlValidatorScope scope) {
-        List<String> signatureList = new ArrayList<>();
-        for (final SqlNode operand : getOperandList()) {
-            final RelDataType argType =
-                    validator.deriveType(Objects.requireNonNull(scope, "scope"), operand);
-            if (null == argType) {
-                continue;
-            }
-            signatureList.add(argType.toString());
-        }
-        return SqlUtil.getOperatorSignature(getOperator(), signatureList);
-    }
-
-    @Override
-    public SqlMonotonicity getMonotonicity(SqlValidatorScope scope) {
-        // Delegate to operator.
-        final SqlCallBinding binding = new SqlCallBinding(scope.getValidator(), scope, this);
-        return getOperator().getMonotonicity(binding);
-    }
-
-    /**
-     * Returns whether it is the function {@code COUNT(*)}.
-     *
-     * @return true if function call to COUNT(*)
-     */
-    public boolean isCountStar() {
-        SqlOperator sqlOperator = getOperator();
-        if (sqlOperator.getName().equals("COUNT") && operandCount() == 1) {
-            final SqlNode parm = operand(0);
-            if (parm instanceof SqlIdentifier) {
-                SqlIdentifier id = (SqlIdentifier) parm;
-                if (id.isStar() && id.names.size() == 1) {
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    }
-
-    @Pure
-    public @Nullable SqlLiteral getFunctionQuantifier() {
-        return null;
-    }
-}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java
deleted file mode 100644
index f6ebfe9df4f2f..0000000000000
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/SqlUtil.java
+++ /dev/null
@@ -1,1368 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.sql;
-
-import com.google.common.base.Predicates;
-import com.google.common.base.Utf8;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterators;
-import com.google.common.collect.Lists;
-import org.apache.calcite.avatica.util.ByteString;
-import org.apache.calcite.linq4j.Ord;
-import org.apache.calcite.linq4j.function.Functions;
-import org.apache.calcite.rel.RelNode;
-import org.apache.calcite.rel.hint.HintStrategyTable;
-import org.apache.calcite.rel.hint.Hintable;
-import org.apache.calcite.rel.hint.RelHint;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.calcite.rel.type.RelDataTypePrecedenceList;
-import org.apache.calcite.runtime.CalciteContextException;
-import org.apache.calcite.runtime.CalciteException;
-import org.apache.calcite.runtime.Resources;
-import org.apache.calcite.sql.fun.SqlInOperator;
-import org.apache.calcite.sql.fun.SqlStdOperatorTable;
-import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.type.SqlOperandMetadata;
-import org.apache.calcite.sql.type.SqlOperandTypeChecker;
-import org.apache.calcite.sql.type.SqlTypeFamily;
-import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.type.SqlTypeUtil;
-import org.apache.calcite.sql.util.SqlBasicVisitor;
-import org.apache.calcite.sql.util.SqlVisitor;
-import org.apache.calcite.sql.validate.SqlNameMatcher;
-import org.apache.calcite.sql.validate.SqlValidatorUtil;
-import org.apache.calcite.util.BarfingInvocationHandler;
-import org.apache.calcite.util.ConversionUtil;
-import org.apache.calcite.util.Glossary;
-import org.apache.calcite.util.Litmus;
-import org.apache.calcite.util.NlsString;
-import org.apache.calcite.util.Pair;
-import org.apache.calcite.util.Util;
-import org.checkerframework.checker.nullness.qual.Nullable;
-import org.checkerframework.checker.nullness.qual.PolyNull;
-
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
-import java.nio.charset.UnsupportedCharsetException;
-import java.sql.DatabaseMetaData;
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
-import static java.util.Objects.requireNonNull;
-import static org.apache.calcite.util.Static.RESOURCE;
-
-/**
- * Flink modification because of CALCITE-7027
- *
- * <p>Lines 827 ~ 833, should be removed after upgrading to 1.40.
- */
-public abstract class SqlUtil {
-    // ~ Constants --------------------------------------------------------------
-
-    /**
-     * Prefix for generated column aliases. Ends with '$' so that human-written queries are unlikely
-     * to accidentally reference the generated name.
-     */
-    public static final String GENERATED_EXPR_ALIAS_PREFIX = "EXPR$";
-
-    // ~ Methods ----------------------------------------------------------------
-
-    /**
-     * Returns the AND of two expressions.
-     *
-     * <p>If {@code node1} is null, returns {@code node2}. Flattens if either node is an AND.
-     */
-    public static SqlNode andExpressions(@Nullable SqlNode node1, SqlNode node2) {
-        if (node1 == null) {
-            return node2;
-        }
-        ArrayList<SqlNode> list = new ArrayList<>();
-        if (node1.getKind() == SqlKind.AND) {
-            list.addAll(((SqlCall) node1).getOperandList());
-        } else {
-            list.add(node1);
-        }
-        if (node2.getKind() == SqlKind.AND) {
-            list.addAll(((SqlCall) node2).getOperandList());
-        } else {
-            list.add(node2);
-        }
-        return SqlStdOperatorTable.AND.createCall(SqlParserPos.ZERO, list);
-    }
-
-    static ArrayList<SqlNode> flatten(SqlNode node) {
-        ArrayList<SqlNode> list = new ArrayList<>();
-        flatten(node, list);
-        return list;
-    }
-
-    /** Returns the <code>n</code>th (0-based) input to a join expression. */
-    public static SqlNode getFromNode(SqlSelect query, int ordinal) {
-        SqlNode from = query.getFrom();
-        if (from == null) {
-            throw new AssertionError("from must not be null for " + query);
-        }
-        ArrayList<SqlNode> list = flatten(from);
-        return list.get(ordinal);
-    }
-
-    private static void flatten(SqlNode node, ArrayList<SqlNode> list) {
-        switch (node.getKind()) {
-            case JOIN:
-                SqlJoin join = (SqlJoin) node;
-                flatten(join.getLeft(), list);
-                flatten(join.getRight(), list);
-                return;
-            case AS:
-                SqlCall call = (SqlCall) node;
-                flatten(call.operand(0), list);
-                return;
-            default:
-                list.add(node);
-                return;
-        }
-    }
-
-    /** Converts a SqlNode array to a SqlNodeList. */
-    public static SqlNodeList toNodeList(SqlNode[] operands) {
-        SqlNodeList ret = new SqlNodeList(SqlParserPos.ZERO);
-        Collections.addAll(ret, operands);
-        return ret;
-    }
-
-    /**
-     * Finds the index of an expression in a list, comparing using {@link
-     * SqlNode#equalsDeep(SqlNode, Litmus)}.
-     */
-    public static int indexOfDeep(List<? extends SqlNode> list, SqlNode e, Litmus litmus) {
-        for (int i = 0; i < list.size(); i++) {
-            if (e.equalsDeep(list.get(i), litmus)) {
-                return i;
-            }
-        }
-        return -1;
-    }
-
-    /**
-     * Returns whether a node represents the NULL value.
-     *
-     * <p>Examples:
-     *
-     * <ul>
-     *   <li>For {@link SqlLiteral} Unknown, returns false.
-     *   <li>For <code>CAST(NULL AS <i>type</i>)</code>, returns true if <code>
-     * allowCast</code> is true, false otherwise.
-     *   <li>For <code>CAST(CAST(NULL AS <i>type</i>) AS <i>type</i>))</code>, returns false.
-     * </ul>
-     */
-    public static boolean isNullLiteral(@Nullable SqlNode node, boolean allowCast) {
-        if (node instanceof SqlLiteral) {
-            SqlLiteral literal = (SqlLiteral) node;
-            if (literal.getTypeName() == SqlTypeName.NULL) {
-                assert null == literal.getValue();
-                return true;
-            } else {
-                // We don't regard UNKNOWN -- SqlLiteral(null,Boolean) -- as
-                // NULL.
-                return false;
-            }
-        }
-        if (allowCast && node != null) {
-            if (node.getKind() == SqlKind.CAST) {
-                SqlCall call = (SqlCall) node;
-                // node is "CAST(NULL as type)"
-                return isNullLiteral(call.operand(0), false);
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Returns whether a node represents the NULL value or a series of nested <code>
-     * CAST(NULL AS type)</code> calls. For example: <code>
-     * isNull(CAST(CAST(NULL as INTEGER) AS VARCHAR(1)))</code> returns {@code true}.
-     */
-    public static boolean isNull(SqlNode node) {
-        return isNullLiteral(node, false)
-                || node.getKind() == SqlKind.CAST && isNull(((SqlCall) node).operand(0));
-    }
-
-    /**
-     * Returns whether a node is a literal.
-     *
-     * <p>Examples:
-     *
-     * <ul>
-     *   <li>For <code>CAST(literal AS <i>type</i>)</code>, returns true if <code>
-     * allowCast</code> is true, false otherwise.
-     *   <li>For <code>CAST(CAST(literal AS <i>type</i>) AS <i>type</i>))</code>, returns false.
-     * </ul>
-     *
-     * @param node The node, never null.
-     * @param allowCast whether to regard CAST(literal) as a literal
-     * @return Whether the node is a literal
-     */
-    public static boolean isLiteral(SqlNode node, boolean allowCast) {
-        requireNonNull(node, "node");
-        if (node instanceof SqlLiteral) {
-            return true;
-        }
-        if (!allowCast) {
-            return false;
-        }
-        switch (node.getKind()) {
-            case CAST:
-                // "CAST(e AS type)" is literal if "e" is literal
-                return isLiteral(((SqlCall) node).operand(0), true);
-            case MAP_VALUE_CONSTRUCTOR:
-            case ARRAY_VALUE_CONSTRUCTOR:
-                return ((SqlCall) node).getOperandList().stream().allMatch(o -> isLiteral(o, true));
-            case DEFAULT:
-                return true; // DEFAULT is always NULL
-            default:
-                return false;
-        }
-    }
-
-    /**
-     * Returns whether a node is a literal.
-     *
-     * <p>Many constructs which require literals also accept <code>CAST(NULL AS
-     * <i>type</i>)</code>. This method does not accept casts, so you should call {@link
-     * #isNullLiteral} first.
-     *
-     * @param node The node, never null.
-     * @return Whether the node is a literal
-     */
-    public static boolean isLiteral(SqlNode node) {
-        return isLiteral(node, false);
-    }
-
-    /**
-     * Returns whether a node is a literal chain which is used to represent a continued string
-     * literal.
-     *
-     * @param node The node, never null.
-     * @return Whether the node is a literal chain
-     */
-    public static boolean isLiteralChain(SqlNode node) {
-        requireNonNull(node, "node");
-        if (node instanceof SqlCall) {
-            SqlCall call = (SqlCall) node;
-            return call.getKind() == SqlKind.LITERAL_CHAIN;
-        } else {
-            return false;
-        }
-    }
-
-    @Deprecated // to be removed before 2.0
-    public static void unparseFunctionSyntax(SqlOperator operator, SqlWriter writer, SqlCall call) {
-        unparseFunctionSyntax(operator, writer, call, false);
-    }
-
-    /**
-     * Unparses a call to an operator that has function syntax.
-     *
-     * @param operator The operator
-     * @param writer Writer
-     * @param call List of 0 or more operands
-     * @param ordered Whether argument list may end with ORDER BY
-     */
-    public static void unparseFunctionSyntax(
-            SqlOperator operator, SqlWriter writer, SqlCall call, boolean ordered) {
-        if (operator instanceof SqlFunction) {
-            SqlFunction function = (SqlFunction) operator;
-
-            if (function.getFunctionType().isSpecific()) {
-                writer.keyword("SPECIFIC");
-            }
-            SqlIdentifier id = function.getSqlIdentifier();
-            if (id == null) {
-                writer.keyword(operator.getName());
-            } else {
-                unparseSqlIdentifierSyntax(writer, id, true);
-            }
-        } else {
-            writer.print(operator.getName());
-        }
-        if (call.operandCount() == 0) {
-            switch (call.getOperator().getSyntax()) {
-                case FUNCTION_ID:
-                    // For example, the "LOCALTIME" function appears as "LOCALTIME"
-                    // when it has 0 args, not "LOCALTIME()".
-                    return;
-                case FUNCTION_STAR: // E.g. "COUNT(*)"
-                case FUNCTION_ID_CONSTANT: // E.g. "PI()"
-                case FUNCTION: // E.g. "RANK()"
-                case ORDERED_FUNCTION: // E.g. "STRING_AGG(x)"
-                    // fall through - dealt with below
-                    break;
-                default:
-                    break;
-            }
-        }
-        final SqlWriter.Frame frame = writer.startList(SqlWriter.FrameTypeEnum.FUN_CALL, "(", ")");
-        final SqlLiteral quantifier = call.getFunctionQuantifier();
-        if (quantifier != null) {
-            quantifier.unparse(writer, 0, 0);
-        }
-        if (call.operandCount() == 0) {
-            switch (call.getOperator().getSyntax()) {
-                case FUNCTION_STAR:
-                    writer.sep("*");
-                    break;
-                default:
-                    break;
-            }
-        }
-        for (SqlNode operand : call.getOperandList()) {
-            if (ordered && operand instanceof SqlNodeList) {
-                writer.sep("ORDER BY");
-            } else if (ordered && operand.getKind() == SqlKind.SEPARATOR) {
-                writer.sep("SEPARATOR");
-                ((SqlCall) operand).operand(0).unparse(writer, 0, 0);
-                continue;
-            } else {
-                writer.sep(",");
-            }
-            operand.unparse(writer, 0, 0);
-        }
-
-        writer.endList(frame);
-    }
-
-    /**
-     * Unparse a SqlIdentifier syntax.
-     *
-     * @param writer Writer
-     * @param identifier SqlIdentifier
-     * @param asFunctionID Whether this identifier comes from a SqlFunction
-     */
-    public static void unparseSqlIdentifierSyntax(
-            SqlWriter writer, SqlIdentifier identifier, boolean asFunctionID) {
-        final boolean isUnquotedSimple =
-                identifier.isSimple() && !identifier.getParserPosition().isQuoted();
-        final SqlOperator operator =
-                isUnquotedSimple
-                        ? SqlValidatorUtil.lookupSqlFunctionByID(
-                                SqlStdOperatorTable.instance(), identifier, null)
-                        : null;
-        boolean unparsedAsFunc = false;
-        final SqlWriter.Frame frame = writer.startList(SqlWriter.FrameTypeEnum.IDENTIFIER);
-        if (isUnquotedSimple && operator != null) {
-            // Unparse conditions:
-            // 1. If the identifier is quoted or is component, unparse as normal.
-            // 2. If the identifier comes from a sql function, lookup in the
-            // standard sql operator table to see if the function is a builtin,
-            // unparse without quoting for builtins.
-
-            // 3. If the identifier does not come from a function(resolved as a SqlIdentifier),
-            // look up in the standard sql operator table to see if it is a function
-            // with empty argument list, e.g. LOCALTIME, we should not quote
-            // such identifier cause quoted `LOCALTIME` always represents a sql identifier.
-            if (asFunctionID
-                    || operator.getSyntax() == SqlSyntax.FUNCTION_ID
-                    || operator.getSyntax() == SqlSyntax.FUNCTION_ID_CONSTANT) {
-                writer.keyword(identifier.getSimple());
-                unparsedAsFunc = true;
-            }
-        }
-
-        if (!unparsedAsFunc) {
-            for (int i = 0; i < identifier.names.size(); i++) {
-                writer.sep(".");
-                final String name = identifier.names.get(i);
-                final SqlParserPos pos = identifier.getComponentParserPosition(i);
-                if (name.isEmpty()) {
-                    writer.print("*");
-                    writer.setNeedWhitespace(true);
-                } else {
-                    writer.identifier(name, pos.isQuoted());
-                }
-            }
-        }
-        if (null != identifier.getCollation()) {
-            identifier.getCollation().unparse(writer);
-        }
-        writer.endList(frame);
-    }
-
-    public static void unparseBinarySyntax(
-            SqlOperator operator, SqlCall call, SqlWriter writer, int leftPrec, int rightPrec) {
-        assert call.operandCount() == 2;
-        final SqlWriter.Frame frame =
-                writer.startList(
-                        (operator instanceof SqlSetOperator)
-                                ? SqlWriter.FrameTypeEnum.SETOP
-                                : SqlWriter.FrameTypeEnum.SIMPLE);
-        call.operand(0).unparse(writer, leftPrec, operator.getLeftPrec());
-        final boolean needsSpace = operator.needsSpace();
-        writer.setNeedWhitespace(needsSpace);
-        writer.sep(operator.getName());
-        writer.setNeedWhitespace(needsSpace);
-        call.operand(1).unparse(writer, operator.getRightPrec(), rightPrec);
-        writer.endList(frame);
-    }
-
-    /**
-     * Concatenates string literals.
-     *
-     * <p>This method takes an array of arguments, since pairwise concatenation means too much
-     * string copying.
-     *
-     * @param lits an array of {@link SqlLiteral}, not empty, all of the same class
-     * @return a new {@link SqlLiteral}, of that same class, whose value is the string concatenation
-     *     of the values of the literals
-     * @throws ClassCastException if the lits are not homogeneous.
-     * @throws ArrayIndexOutOfBoundsException if lits is an empty array.
-     */
-    public static SqlLiteral concatenateLiterals(List<SqlLiteral> lits) {
-        if (lits.size() == 1) {
-            return lits.get(0); // nothing to do
-        }
-        return ((SqlAbstractStringLiteral) lits.get(0)).concat1(lits);
-    }
-
-    /**
-     * Looks up a (possibly overloaded) routine based on name and argument types.
-     *
-     * @param opTab operator table to search
-     * @param typeFactory Type factory
-     * @param funcName name of function being invoked
-     * @param argTypes argument types
-     * @param argNames argument names, or null if call by position
-     * @param category whether a function or a procedure. (If a procedure is being invoked, the
-     *     overload rules are simpler.)
-     * @param nameMatcher Whether to look up the function case-sensitively
-     * @param coerce Whether to allow type coercion when do filter routines by parameter types
-     * @return matching routine, or null if none found
-     * @see Glossary#SQL99 SQL:1999 Part 2 Section 10.4
-     */
-    public static @Nullable SqlOperator lookupRoutine(
-            SqlOperatorTable opTab,
-            RelDataTypeFactory typeFactory,
-            SqlIdentifier funcName,
-            List<RelDataType> argTypes,
-            @Nullable List<String> argNames,
-            @Nullable SqlFunctionCategory category,
-            SqlSyntax syntax,
-            SqlKind sqlKind,
-            SqlNameMatcher nameMatcher,
-            boolean coerce) {
-        Iterator<SqlOperator> list =
-                lookupSubjectRoutines(
-                        opTab,
-                        typeFactory,
-                        funcName,
-                        argTypes,
-                        argNames,
-                        syntax,
-                        sqlKind,
-                        category,
-                        nameMatcher,
-                        coerce);
-        if (list.hasNext()) {
-            // return first on schema path
-            return list.next();
-        }
-        return null;
-    }
-
-    private static Iterator<SqlOperator> filterOperatorRoutinesByKind(
-            Iterator<SqlOperator> routines, final SqlKind sqlKind) {
-        return Iterators.filter(
-                routines,
-                operator ->
-                        requireNonNull(operator, "operator").getKind().getFunctionKind()
-                                == sqlKind);
-    }
-
-    /**
-     * Looks up all subject routines matching the given name and argument types.
-     *
-     * @param opTab operator table to search
-     * @param typeFactory Type factory
-     * @param funcName name of function being invoked
-     * @param argTypes argument types
-     * @param argNames argument names, or null if call by position
-     * @param sqlSyntax the SqlSyntax of the SqlOperator being looked up
-     * @param sqlKind the SqlKind of the SqlOperator being looked up
-     * @param category Category of routine to look up
-     * @param nameMatcher Whether to look up the function case-sensitively
-     * @param coerce Whether to allow type coercion when do filter routine by parameter types
-     * @return list of matching routines
-     * @see Glossary#SQL99 SQL:1999 Part 2 Section 10.4
-     */
-    public static Iterator<SqlOperator> lookupSubjectRoutines(
-            SqlOperatorTable opTab,
-            RelDataTypeFactory typeFactory,
-            SqlIdentifier funcName,
-            List<RelDataType> argTypes,
-            @Nullable List<String> argNames,
-            SqlSyntax sqlSyntax,
-            SqlKind sqlKind,
-            @Nullable SqlFunctionCategory category,
-            SqlNameMatcher nameMatcher,
-            boolean coerce) {
-        // start with all routines matching by name
-        Iterator<SqlOperator> routines =
-                lookupSubjectRoutinesByName(opTab, funcName, sqlSyntax, category, nameMatcher);
-
-        // first pass:  eliminate routines which don't accept the given
-        // number of arguments
-        routines = filterRoutinesByParameterCount(routines, argTypes);
-
-        // NOTE: according to SQL99, procedures are NOT overloaded on type,
-        // only on number of arguments.
-        if (category == SqlFunctionCategory.USER_DEFINED_PROCEDURE) {
-            return routines;
-        }
-
-        // second pass:  eliminate routines which don't accept the given
-        // argument types and parameter names if specified
-        routines =
-                filterRoutinesByParameterTypeAndName(
-                        typeFactory, sqlSyntax, routines, argTypes, argNames, coerce);
-
-        // see if we can stop now; this is necessary for the case
-        // of builtin functions where we don't have param type info,
-        // or UDF whose operands can make type coercion.
-        final List<SqlOperator> list = Lists.newArrayList(routines);
-        routines = list.iterator();
-        if (list.size() < 2 || coerce) {
-            return routines;
-        }
-
-        // third pass:  for each parameter from left to right, eliminate
-        // all routines except those with the best precedence match for
-        // the given arguments
-        routines =
-                filterRoutinesByTypePrecedence(
-                        sqlSyntax, typeFactory, routines, argTypes, argNames);
-
-        // fourth pass: eliminate routines which do not have the same
-        // SqlKind as requested
-        return filterOperatorRoutinesByKind(routines, sqlKind);
-    }
-
-    /**
-     * Determines whether there is a routine matching the given name and number of arguments.
-     *
-     * @param opTab operator table to search
-     * @param funcName name of function being invoked
-     * @param argTypes argument types
-     * @param category category of routine to look up
-     * @param nameMatcher Whether to look up the function case-sensitively
-     * @return true if match found
-     */
-    public static boolean matchRoutinesByParameterCount(
-            SqlOperatorTable opTab,
-            SqlIdentifier funcName,
-            List<RelDataType> argTypes,
-            SqlFunctionCategory category,
-            SqlNameMatcher nameMatcher) {
-        // start with all routines matching by name
-        Iterator<SqlOperator> routines =
-                lookupSubjectRoutinesByName(
-                        opTab, funcName, SqlSyntax.FUNCTION, category, nameMatcher);
-
-        // first pass:  eliminate routines which don't accept the given
-        // number of arguments
-        routines = filterRoutinesByParameterCount(routines, argTypes);
-
-        return routines.hasNext();
-    }
-
-    private static Iterator<SqlOperator> lookupSubjectRoutinesByName(
-            SqlOperatorTable opTab,
-            SqlIdentifier funcName,
-            final SqlSyntax syntax,
-            @Nullable SqlFunctionCategory category,
-            SqlNameMatcher nameMatcher) {
-        final List<SqlOperator> sqlOperators = new ArrayList<>();
-        opTab.lookupOperatorOverloads(funcName, category, syntax, sqlOperators, nameMatcher);
-        switch (syntax) {
-            case FUNCTION:
-                return Iterators.filter(
-                        sqlOperators.iterator(), Predicates.instanceOf(SqlFunction.class));
-            default:
-                return Iterators.filter(
-                        sqlOperators.iterator(),
-                        operator -> requireNonNull(operator, "operator").getSyntax() == syntax);
-        }
-    }
-
-    private static Iterator<SqlOperator> filterRoutinesByParameterCount(
-            Iterator<SqlOperator> routines, final List<RelDataType> argTypes) {
-        return Iterators.filter(
-                routines,
-                operator ->
-                        requireNonNull(operator, "operator")
-                                .getOperandCountRange()
-                                .isValidCount(argTypes.size()));
-    }
-
-    /**
-     * Filters an iterator of routines, keeping only those that have the required argument types and
-     * names.
-     *
-     * @see Glossary#SQL99 SQL:1999 Part 2 Section 10.4 Syntax Rule 6.b.iii.2.B
-     */
-    private static Iterator<SqlOperator> filterRoutinesByParameterTypeAndName(
-            RelDataTypeFactory typeFactory,
-            SqlSyntax syntax,
-            final Iterator<SqlOperator> routines,
-            final List<RelDataType> argTypes,
-            final @Nullable List<String> argNames,
-            final boolean coerce) {
-        if (syntax != SqlSyntax.FUNCTION) {
-            return routines;
-        }
-
-        //noinspection unchecked
-        return (Iterator)
-                Iterators.filter(
-                        Iterators.filter(routines, SqlFunction.class),
-                        function -> {
-                            SqlOperandTypeChecker operandTypeChecker =
-                                    requireNonNull(function, "function").getOperandTypeChecker();
-                            if (operandTypeChecker == null
-                                    || !operandTypeChecker.isFixedParameters()) {
-                                // no parameter information for builtins; keep for now,
-                                // the type coerce will not work here.
-                                return true;
-                            }
-                            final SqlOperandMetadata operandMetadata =
-                                    (SqlOperandMetadata) operandTypeChecker;
-                            @SuppressWarnings("assignment.type.incompatible")
-                            final List<@Nullable RelDataType> paramTypes =
-                                    operandMetadata.paramTypes(typeFactory);
-                            final List<@Nullable RelDataType> permutedArgTypes;
-                            if (argNames != null) {
-                                final List<String> paramNames = operandMetadata.paramNames();
-                                permutedArgTypes = permuteArgTypes(paramNames, argNames, argTypes);
-                                if (permutedArgTypes == null) {
-                                    return false;
-                                }
-                            } else {
-                                permutedArgTypes = Lists.newArrayList(argTypes);
-                                while (permutedArgTypes.size() < argTypes.size()) {
-                                    paramTypes.add(null);
-                                }
-                            }
-                            for (Pair<@Nullable RelDataType, @Nullable RelDataType> p :
-                                    Pair.zip(paramTypes, permutedArgTypes)) {
-                                final RelDataType argType = p.right;
-                                final RelDataType paramType = p.left;
-                                if (argType != null
-                                        && paramType != null
-                                        && !SqlTypeUtil.canCastFrom(paramType, argType, coerce)) {
-                                    return false;
-                                }
-                            }
-                            return true;
-                        });
-    }
-
-    /** Permutes argument types to correspond to the order of parameter names. */
-    private static @Nullable List<@Nullable RelDataType> permuteArgTypes(
-            List<String> paramNames, List<String> argNames, List<RelDataType> argTypes) {
-        // Arguments passed by name. Make sure that the function has
-        // parameters of all of these names.
-        Map<Integer, Integer> map = new HashMap<>();
-        for (Ord<String> argName : Ord.zip(argNames)) {
-            int i = paramNames.indexOf(argName.e);
-            if (i < 0) {
-                return null;
-            }
-            map.put(i, argName.i);
-        }
-        return Functions.<@Nullable RelDataType>generate(
-                paramNames.size(),
-                index -> {
-                    Integer argIndex = map.get(index);
-                    return argIndex != null ? argTypes.get(argIndex) : null;
-                });
-    }
-
-    /**
-     * Filters an iterator of routines, keeping only those with the best match for the actual
-     * argument types.
-     *
-     * @see Glossary#SQL99 SQL:1999 Part 2 Section 9.4
-     */
-    private static Iterator<SqlOperator> filterRoutinesByTypePrecedence(
-            SqlSyntax sqlSyntax,
-            RelDataTypeFactory typeFactory,
-            Iterator<SqlOperator> routines,
-            List<RelDataType> argTypes,
-            @Nullable List<String> argNames) {
-        if (sqlSyntax != SqlSyntax.FUNCTION) {
-            return routines;
-        }
-
-        List<SqlFunction> sqlFunctions =
-                Lists.newArrayList(Iterators.filter(routines, SqlFunction.class));
-
-        for (final Ord<RelDataType> argType : Ord.zip(argTypes)) {
-            final RelDataTypePrecedenceList precList = argType.e.getPrecedenceList();
-            final RelDataType bestMatch =
-                    bestMatch(typeFactory, sqlFunctions, argType.i, argNames, precList);
-            if (bestMatch != null) {
-                sqlFunctions =
-                        sqlFunctions.stream()
-                                .filter(
-                                        function -> {
-                                            SqlOperandTypeChecker operandTypeChecker =
-                                                    function.getOperandTypeChecker();
-                                            if (operandTypeChecker == null
-                                                    || !operandTypeChecker.isFixedParameters()) {
-                                                return false;
-                                            }
-                                            final SqlOperandMetadata operandMetadata =
-                                                    (SqlOperandMetadata) operandTypeChecker;
-                                            final List<String> paramNames =
-                                                    operandMetadata.paramNames();
-                                            final List<RelDataType> paramTypes =
-                                                    operandMetadata.paramTypes(typeFactory);
-                                            int index =
-                                                    argNames != null
-                                                            ? paramNames.indexOf(
-                                                                    argNames.get(argType.i))
-                                                            : argType.i;
-                                            final RelDataType paramType = paramTypes.get(index);
-                                            return precList.compareTypePrecedence(
-                                                            paramType, bestMatch)
-                                                    >= 0;
-                                        })
-                                .collect(Collectors.toList());
-            }
-        }
-        //noinspection unchecked
-        return (Iterator) sqlFunctions.iterator();
-    }
-
-    private static @Nullable RelDataType bestMatch(
-            RelDataTypeFactory typeFactory,
-            List<SqlFunction> sqlFunctions,
-            int i,
-            @Nullable List<String> argNames,
-            RelDataTypePrecedenceList precList) {
-        RelDataType bestMatch = null;
-        for (SqlFunction function : sqlFunctions) {
-            SqlOperandTypeChecker operandTypeChecker = function.getOperandTypeChecker();
-            if (operandTypeChecker == null || !operandTypeChecker.isFixedParameters()) {
-                continue;
-            }
-            final SqlOperandMetadata operandMetadata = (SqlOperandMetadata) operandTypeChecker;
-            final List<RelDataType> paramTypes = operandMetadata.paramTypes(typeFactory);
-            final List<String> paramNames = operandMetadata.paramNames();
-            final RelDataType paramType =
-                    argNames != null
-                            ? paramTypes.get(paramNames.indexOf(argNames.get(i)))
-                            : paramTypes.get(i);
-            if (bestMatch == null) {
-                bestMatch = paramType;
-            } else {
-                int c = precList.compareTypePrecedence(bestMatch, paramType);
-                if (c < 0) {
-                    bestMatch = paramType;
-                }
-            }
-        }
-        return bestMatch;
-    }
-
-    /** Returns the <code>i</code>th select-list item of a query. */
-    public static SqlNode getSelectListItem(SqlNode query, int i) {
-        switch (query.getKind()) {
-            case SELECT:
-                SqlSelect select = (SqlSelect) query;
-                SqlNode from = select.getFrom();
-                if (from != null) {
-                    from = stripAs(from);
-                    if (from.getKind() == SqlKind.VALUES) {
-                        // They wrote "VALUES (x, y)", but the validator has
-                        // converted this into "SELECT * FROM VALUES (x, y)".
-                        return getSelectListItem(from, i);
-                    }
-                }
-
-                final SqlNodeList fields = select.getSelectList();
-                // Range check the index to avoid index out of range.  This
-                // could be expanded to actually check to see if the select
-                // list is a "*"
-                if (i >= fields.size()) {
-                    i = 0;
-                }
-                return fields.get(i);
-
-            case VALUES:
-                SqlCall call = (SqlCall) query;
-                assert call.operandCount() > 0 : "VALUES must have at least one operand";
-                final SqlCall row = call.operand(0);
-                assert row.operandCount() > i : "VALUES has too few columns";
-                return row.operand(i);
-
-            // FLINK MODIFICATION BEGIN
-            case EXCEPT:
-            case INTERSECT:
-            case UNION:
-                final List<SqlNode> operandList = ((SqlBasicCall) query).getOperandList();
-                return getSelectListItem(operandList.get(0), i);
-            // FLINK MODIFICATION END
-
-            default:
-                // Unexpected type of query.
-                throw Util.needToImplement(query);
-        }
-    }
-
-    public static String deriveAliasFromOrdinal(int ordinal) {
-        return GENERATED_EXPR_ALIAS_PREFIX + ordinal;
-    }
-
-    /**
-     * Whether the alias is generated by calcite.
-     *
-     * @param alias not null
-     * @return true if alias is generated by calcite, otherwise false
-     */
-    public static boolean isGeneratedAlias(String alias) {
-        return requireNonNull(alias, "alias")
-                .toUpperCase(Locale.ROOT)
-                .startsWith(GENERATED_EXPR_ALIAS_PREFIX);
-    }
-
-    /**
-     * Constructs an operator signature from a type list.
-     *
-     * @param op operator
-     * @param typeList list of types to use for operands. Types may be represented as {@link
-     *     String}, {@link SqlTypeFamily}, or any object with a valid {@link Object#toString()}
-     *     method.
-     * @return constructed signature
-     */
-    public static String getOperatorSignature(SqlOperator op, List<?> typeList) {
-        return getAliasedSignature(op, op.getName(), typeList);
-    }
-
-    /**
-     * Constructs an operator signature from a type list, substituting an alias for the operator
-     * name.
-     *
-     * @param op operator
-     * @param opName name to use for operator
-     * @param typeList list of {@link SqlTypeName} or {@link String} to use for operands
-     * @return constructed signature
-     */
-    public static String getAliasedSignature(SqlOperator op, String opName, List<?> typeList) {
-        StringBuilder ret = new StringBuilder();
-        String template = op.getSignatureTemplate(typeList.size());
-        if (null == template) {
-            ret.append("'");
-            ret.append(opName);
-            ret.append("(");
-            for (int i = 0; i < typeList.size(); i++) {
-                if (i > 0) {
-                    ret.append(", ");
-                }
-                final String t = String.valueOf(typeList.get(i)).toUpperCase(Locale.ROOT);
-                ret.append("<").append(t).append(">");
-            }
-            ret.append(")'");
-        } else {
-            Object[] values = new Object[typeList.size() + 1];
-            values[0] = opName;
-            ret.append("'");
-            for (int i = 0; i < typeList.size(); i++) {
-                final String t = String.valueOf(typeList.get(i)).toUpperCase(Locale.ROOT);
-                values[i + 1] = "<" + t + ">";
-            }
-            ret.append(new MessageFormat(template, Locale.ROOT).format(values));
-            ret.append("'");
-            assert (typeList.size() + 1) == values.length;
-        }
-
-        return ret.toString();
-    }
-
-    /** Wraps an exception with context. */
-    public static CalciteException newContextException(
-            final SqlParserPos pos, Resources.ExInst<?> e, String inputText) {
-        CalciteContextException ex = newContextException(pos, e);
-        ex.setOriginalStatement(inputText);
-        return ex;
-    }
-
-    /** Wraps an exception with context. */
-    public static CalciteContextException newContextException(
-            final SqlParserPos pos, Resources.ExInst<?> e) {
-        int line = pos.getLineNum();
-        int col = pos.getColumnNum();
-        int endLine = pos.getEndLineNum();
-        int endCol = pos.getEndColumnNum();
-        return newContextException(line, col, endLine, endCol, e);
-    }
-
-    /** Wraps an exception with context. */
-    public static CalciteContextException newContextException(
-            int line, int col, int endLine, int endCol, Resources.ExInst<?> e) {
-        CalciteContextException contextExcn =
-                (line == endLine && col == endCol
-                                ? RESOURCE.validatorContextPoint(line, col)
-                                : RESOURCE.validatorContext(line, col, endLine, endCol))
-                        .ex(e.ex());
-        contextExcn.setPosition(line, col, endLine, endCol);
-        return contextExcn;
-    }
-
-    /**
-     * Returns whether a {@link SqlNode node} is a {@link SqlCall call} to a given {@link
-     * SqlOperator operator}.
-     */
-    public static boolean isCallTo(SqlNode node, SqlOperator operator) {
-        return (node instanceof SqlCall) && (((SqlCall) node).getOperator() == operator);
-    }
-
-    /**
-     * Creates the type of an {@link org.apache.calcite.util.NlsString}.
-     *
-     * <p>The type inherits the NlsString's {@link Charset} and {@link SqlCollation}, if they are
-     * set, otherwise it gets the system defaults.
-     *
-     * @param typeFactory Type factory
-     * @param str String
-     * @return Type, including collation and charset
-     */
-    public static RelDataType createNlsStringType(RelDataTypeFactory typeFactory, NlsString str) {
-        Charset charset = str.getCharset();
-        if (null == charset) {
-            charset = typeFactory.getDefaultCharset();
-        }
-        SqlCollation collation = str.getCollation();
-        if (null == collation) {
-            collation = SqlCollation.COERCIBLE;
-        }
-        RelDataType type = typeFactory.createSqlType(SqlTypeName.CHAR, str.getValue().length());
-        type = typeFactory.createTypeWithCharsetAndCollation(type, charset, collation);
-        return type;
-    }
-
-    /**
-     * Translates a character set name from a SQL-level name into a Java-level name.
-     *
-     * @param name SQL-level name
-     * @return Java-level name, or null if SQL-level name is unknown
-     */
-    public static @Nullable String translateCharacterSetName(String name) {
-        switch (name) {
-            case "BIG5":
-                return "Big5";
-            case "LATIN1":
-                return "ISO-8859-1";
-            case "UTF8":
-                return "UTF-8";
-            case "UTF16":
-            case "UTF-16":
-                return ConversionUtil.NATIVE_UTF16_CHARSET_NAME;
-            case "GB2312":
-            case "GBK":
-            case "UTF-16BE":
-            case "UTF-16LE":
-            case "ISO-8859-1":
-            case "UTF-8":
-                return name;
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * Returns the Java-level {@link Charset} based on given SQL-level name.
-     *
-     * @param charsetName Sql charset name, must not be null.
-     * @return charset, or default charset if charsetName is null.
-     * @throws UnsupportedCharsetException If no support for the named charset is available in this
-     *     instance of the Java virtual machine
-     */
-    public static Charset getCharset(String charsetName) {
-        String javaCharsetName =
-                translateCharacterSetName(
-                        requireNonNull(charsetName, "charsetName").toUpperCase(Locale.ROOT));
-        if (javaCharsetName == null) {
-            throw new UnsupportedCharsetException(charsetName);
-        }
-        return Charset.forName(javaCharsetName);
-    }
-
-    /**
-     * Validate if value can be decoded by given charset.
-     *
-     * @param value nls string in byte array
-     * @param charset charset
-     * @throws RuntimeException If the given value cannot be represented in the given charset
-     */
-    public static void validateCharset(ByteString value, Charset charset) {
-        if (charset == StandardCharsets.UTF_8) {
-            final byte[] bytes = value.getBytes();
-            if (!Utf8.isWellFormed(bytes)) {
-                // CHECKSTYLE: IGNORE 1
-                final String string = new String(bytes, charset);
-                throw RESOURCE.charsetEncoding(string, charset.name()).ex();
-            }
-        }
-    }
-
-    /**
-     * If a node is "AS", returns the underlying expression; otherwise returns the node. Returns
-     * null if and only if the node is null.
-     */
-    public static @PolyNull SqlNode stripAs(@PolyNull SqlNode node) {
-        if (node != null && node.getKind() == SqlKind.AS) {
-            return ((SqlCall) node).operand(0);
-        }
-        return node;
-    }
-
-    /**
-     * Modifies a list of nodes, removing AS from each if present.
-     *
-     * @see #stripAs
-     */
-    public static SqlNodeList stripListAs(SqlNodeList nodeList) {
-        for (int i = 0; i < nodeList.size(); i++) {
-            SqlNode n = nodeList.get(i);
-            SqlNode n2 = stripAs(n);
-            if (n != n2) {
-                nodeList.set(i, n2);
-            }
-        }
-        return nodeList;
-    }
-
-    /**
-     * Returns a list of ancestors of {@code predicate} within a given {@code SqlNode} tree.
-     *
-     * <p>The first element of the list is {@code root}, and the last is the node that matched
-     * {@code predicate}. Throws if no node matches.
-     */
-    public static ImmutableList<SqlNode> getAncestry(
-            SqlNode root, Predicate<SqlNode> predicate, Predicate<SqlNode> postPredicate) {
-        try {
-            new Genealogist(predicate, postPredicate).visitChild(root);
-            throw new AssertionError("not found: " + predicate + " in " + root);
-        } catch (Util.FoundOne e) {
-            //noinspection unchecked
-            return (ImmutableList<SqlNode>) requireNonNull(e.getNode(), "Genealogist result");
-        }
-    }
-
-    /**
-     * Returns an immutable list of {@link RelHint} from sql hints, with a given inherit path from
-     * the root node.
-     *
-     * <p>The inherit path would be empty list.
-     *
-     * @param hintStrategies The hint strategies to validate the sql hints
-     * @param sqlHints The sql hints nodes
-     * @return the {@code RelHint} list
-     */
-    public static List<RelHint> getRelHint(
-            HintStrategyTable hintStrategies, @Nullable SqlNodeList sqlHints) {
-        if (sqlHints == null || sqlHints.isEmpty()) {
-            return ImmutableList.of();
-        }
-        final ImmutableList.Builder<RelHint> relHints = ImmutableList.builder();
-        for (SqlNode node : sqlHints) {
-            assert node instanceof SqlHint;
-            final SqlHint sqlHint = (SqlHint) node;
-            final String hintName = sqlHint.getName();
-
-            final RelHint.Builder builder = RelHint.builder(hintName);
-            switch (sqlHint.getOptionFormat()) {
-                case EMPTY:
-                    // do nothing.
-                    break;
-                case LITERAL_LIST:
-                case ID_LIST:
-                    builder.hintOptions(sqlHint.getOptionList());
-                    break;
-                case KV_LIST:
-                    builder.hintOptions(sqlHint.getOptionKVPairs());
-                    break;
-                default:
-                    throw new AssertionError("Unexpected hint option format");
-            }
-            final RelHint relHint = builder.build();
-            if (hintStrategies.validateHint(relHint)) {
-                // Skips the hint if the validation fails.
-                relHints.add(relHint);
-            }
-        }
-        return relHints.build();
-    }
-
-    /**
-     * Attach the {@code hints} to {@code rel} with specified hint strategies.
-     *
-     * @param hintStrategies The strategies to filter the hints
-     * @param hints The original hints to be attached
-     * @return A copy of {@code rel} if there are any hints can be attached given the hint
-     *     strategies, or the original node if such hints don't exist
-     */
-    public static RelNode attachRelHint(
-            HintStrategyTable hintStrategies, List<RelHint> hints, Hintable rel) {
-        final List<RelHint> relHints = hintStrategies.apply(hints, (RelNode) rel);
-        if (!relHints.isEmpty()) {
-            return rel.attachHints(relHints);
-        }
-        return (RelNode) rel;
-    }
-
-    /**
-     * Creates a call to an operator.
-     *
-     * <p>Deals with the fact the AND and OR are binary.
-     */
-    public static SqlNode createCall(SqlOperator op, SqlParserPos pos, List<SqlNode> operands) {
-        switch (op.kind) {
-            case OR:
-            case AND:
-                // In RexNode trees, OR and AND have any number of children;
-                // SqlCall requires exactly 2. So, convert to a balanced binary
-                // tree for OR/AND, left-deep binary tree for others.
-                switch (operands.size()) {
-                    case 0:
-                        return SqlLiteral.createBoolean(op.kind == SqlKind.AND, pos);
-                    case 1:
-                        return operands.get(0);
-                    default:
-                        return createBalancedCall(op, pos, operands, 0, operands.size());
-                    case 2:
-                    case 3:
-                    case 4:
-                    case 5:
-                        // fall through
-                }
-                // fall through
-                break;
-            default:
-                break;
-        }
-        if (op instanceof SqlBinaryOperator && operands.size() > 2) {
-            return createLeftCall(op, pos, operands);
-        }
-        return op.createCall(pos, operands);
-    }
-
-    private static SqlNode createLeftCall(
-            SqlOperator op, SqlParserPos pos, List<SqlNode> nodeList) {
-        SqlNode node = op.createCall(pos, nodeList.subList(0, 2));
-        for (int i = 2; i < nodeList.size(); i++) {
-            node = op.createCall(pos, node, nodeList.get(i));
-        }
-        return node;
-    }
-
-    /** Creates a balanced binary call from sql node list, start inclusive, end exclusive. */
-    private static SqlNode createBalancedCall(
-            SqlOperator op, SqlParserPos pos, List<SqlNode> operands, int start, int end) {
-        assert start < end && end <= operands.size();
-        if (start + 1 == end) {
-            return operands.get(start);
-        }
-        int mid = (end - start) / 2 + start;
-        SqlNode leftNode = createBalancedCall(op, pos, operands, start, mid);
-        SqlNode rightNode = createBalancedCall(op, pos, operands, mid, end);
-        return op.createCall(pos, leftNode, rightNode);
-    }
-
-    /**
-     * Returns whether a given node contains a {@link SqlInOperator}.
-     *
-     * @param node AST tree
-     */
-    public static boolean containsIn(SqlNode node) {
-        final Predicate<SqlCall> callPredicate =
-                call -> call.getOperator() instanceof SqlInOperator;
-        return containsCall(node, callPredicate);
-    }
-
-    /**
-     * Returns whether a given node contains a {@link SqlKind#DEFAULT} expression.
-     *
-     * @param node AST tree
-     */
-    public static boolean containsDefault(SqlNode node) {
-        final Predicate<SqlCall> callPredicate = call -> call.getKind() == SqlKind.DEFAULT;
-        return containsCall(node, callPredicate);
-    }
-
-    /**
-     * Returns whether an AST tree contains a call to an aggregate function.
-     *
-     * @param node AST tree
-     */
-    public static boolean containsAgg(SqlNode node) {
-        final Predicate<SqlCall> callPredicate = call -> call.getOperator().isAggregator();
-        return containsCall(node, callPredicate);
-    }
-
-    /** Returns whether an AST tree contains a call that matches a given predicate. */
-    public static boolean containsCall(SqlNode node, Predicate<SqlCall> callPredicate) {
-        try {
-            SqlVisitor<Void> visitor =
-                    new SqlBasicVisitor<Void>() {
-                        @Override
-                        public Void visit(SqlCall call) {
-                            if (callPredicate.test(call)) {
-                                throw new Util.FoundOne(call);
-                            }
-                            return super.visit(call);
-                        }
-                    };
-            node.accept(visitor);
-            return false;
-        } catch (Util.FoundOne e) {
-            Util.swallow(e, null);
-            return true;
-        }
-    }
-
-    // ~ Inner Classes ----------------------------------------------------------
-
-    /**
-     * Handles particular {@link DatabaseMetaData} methods; invocations of other methods will fall
-     * through to the base class, {@link org.apache.calcite.util.BarfingInvocationHandler}, which
-     * will throw an error.
-     */
-    public static class DatabaseMetaDataInvocationHandler extends BarfingInvocationHandler {
-        private final String databaseProductName;
-        private final String identifierQuoteString;
-
-        public DatabaseMetaDataInvocationHandler(
-                String databaseProductName, String identifierQuoteString) {
-            this.databaseProductName = databaseProductName;
-            this.identifierQuoteString = identifierQuoteString;
-        }
-
-        public String getDatabaseProductName() {
-            return databaseProductName;
-        }
-
-        public String getIdentifierQuoteString() {
-            return identifierQuoteString;
-        }
-    }
-
-    /**
-     * Walks over a {@link org.apache.calcite.sql.SqlNode} tree and returns the ancestry stack when
-     * it finds a given node.
-     */
-    private static class Genealogist extends SqlBasicVisitor<Void> {
-        private final List<SqlNode> ancestors = new ArrayList<>();
-        private final Predicate<SqlNode> predicate;
-        private final Predicate<SqlNode> postPredicate;
-
-        Genealogist(Predicate<SqlNode> predicate, Predicate<SqlNode> postPredicate) {
-            this.predicate = predicate;
-            this.postPredicate = postPredicate;
-        }
-
-        private Void check(SqlNode node) {
-            preCheck(node);
-            postCheck(node);
-            return null;
-        }
-
-        private Void preCheck(SqlNode node) {
-            if (predicate.test(node)) {
-                throw new Util.FoundOne(ImmutableList.copyOf(ancestors));
-            }
-            return null;
-        }
-
-        private Void postCheck(SqlNode node) {
-            if (postPredicate.test(node)) {
-                throw new Util.FoundOne(ImmutableList.copyOf(ancestors));
-            }
-            return null;
-        }
-
-        private void visitChild(@Nullable SqlNode node) {
-            if (node == null) {
-                return;
-            }
-            ancestors.add(node);
-            node.accept(this);
-            ancestors.remove(ancestors.size() - 1);
-        }
-
-        @Override
-        public Void visit(SqlIdentifier id) {
-            return check(id);
-        }
-
-        @Override
-        public Void visit(SqlCall call) {
-            preCheck(call);
-            for (SqlNode node : call.getOperandList()) {
-                visitChild(node);
-            }
-            return postCheck(call);
-        }
-
-        @Override
-        public Void visit(SqlIntervalQualifier intervalQualifier) {
-            return check(intervalQualifier);
-        }
-
-        @Override
-        public Void visit(SqlLiteral literal) {
-            return check(literal);
-        }
-
-        @Override
-        public Void visit(SqlNodeList nodeList) {
-            preCheck(nodeList);
-            for (SqlNode node : nodeList) {
-                visitChild(node);
-            }
-            return postCheck(nodeList);
-        }
-
-        @Override
-        public Void visit(SqlDynamicParam param) {
-            return check(param);
-        }
-
-        @Override
-        public Void visit(SqlDataTypeSpec type) {
-            return check(type);
-        }
-    }
-}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/fun/SqlCoalesceFunction.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/fun/SqlCoalesceFunction.java
index 59e99e5cba2f2..556a0c2abd2bf 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/fun/SqlCoalesceFunction.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/fun/SqlCoalesceFunction.java
@@ -16,25 +16,32 @@
  */
 package org.apache.calcite.sql.fun;
 
+import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.sql.SqlBasicCall;
 import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlCallBinding;
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlOperatorBinding;
 import org.apache.calcite.sql.SqlUtil;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
 import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.type.SqlTypeTransforms;
+import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.implicit.TypeCoercion;
+import org.checkerframework.checker.nullness.qual.NonNull;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import static java.util.Objects.requireNonNull;
+import static org.apache.calcite.util.Static.RESOURCE;
 
 /** The class copied from Calcite in order to turn off COALESCE rewrite with CASE ... WHEN ... */
 public class SqlCoalesceFunction extends SqlFunction {
@@ -89,6 +96,43 @@ public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
 
     // ----- FLINK MODIFICATION END -----
 
+    @Override
+    @NonNull
+    public RelDataType inferReturnType(SqlOperatorBinding opBinding) {
+        RelDataType returnType = getReturnTypeInference().inferReturnType(opBinding);
+        if (returnType == null
+                && opBinding instanceof SqlCallBinding
+                && ((SqlCallBinding) opBinding).isTypeCoercionEnabled()) {
+            SqlCallBinding callBinding = (SqlCallBinding) opBinding;
+            List<RelDataType> argTypes = new ArrayList<>();
+            for (SqlNode operand : callBinding.operands()) {
+                RelDataType type = SqlTypeUtil.deriveType(callBinding, operand);
+                argTypes.add(type);
+            }
+            TypeCoercion typeCoercion = callBinding.getValidator().getTypeCoercion();
+            RelDataType commonType = typeCoercion.getWiderTypeFor(argTypes, true);
+            if (null != commonType) {
+                // COALESCE type coercion, find a common type across all branches and casts
+                // operands to this common type if necessary.
+                boolean coerced = typeCoercion.caseOrEquivalentCoercion(callBinding);
+                if (coerced) {
+                    return SqlTypeUtil.deriveType(callBinding);
+                }
+            }
+            throw callBinding.newValidationError(RESOURCE.illegalMixingOfTypes());
+        }
+
+        if (returnType == null) {
+            throw new IllegalArgumentException(
+                    "Cannot infer return type for "
+                            + opBinding.getOperator()
+                            + "; operand types: "
+                            + opBinding.collectOperandTypes());
+        }
+
+        return returnType;
+    }
+
     @Override
     public SqlReturnTypeInference getReturnTypeInference() {
         return requireNonNull(super.getReturnTypeInference(), "returnTypeInference");
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index 108df341d2656..640765c51b48d 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -169,6 +169,7 @@
 import static com.google.common.base.Preconditions.checkState;
 import static java.util.Collections.emptyList;
 import static java.util.Objects.requireNonNull;
+import static java.util.stream.Collectors.joining;
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 import static org.apache.calcite.linq4j.Ord.forEach;
 import static org.apache.calcite.sql.SqlUtil.stripAs;
@@ -427,6 +428,7 @@ public SqlNodeList expandStar(
             SqlNodeList selectList, SqlSelect select, boolean includeSystemVars) {
         final List<SqlNode> list = new ArrayList<>();
         final PairList<String, RelDataType> types = PairList.of();
+        final Map<String, SqlNode> expansions = new HashMap<>();
         for (final SqlNode selectItem : selectList) {
             final RelDataType originalType = getValidatedNodeTypeIfKnown(selectItem);
             expandSelectItem(
@@ -436,6 +438,7 @@ public SqlNodeList expandStar(
                     list,
                     catalogReader.nameMatcher().createSet(),
                     types,
+                    expansions,
                     includeSystemVars);
         }
         getRawSelectScopeNonNull(select).setExpandedSelectList(list);
@@ -490,6 +493,8 @@ public void popFunctionCall() {
      * @param selectItems List that expanded items are written to
      * @param aliases Set of aliases
      * @param fields List of field names and types, in alias order
+     * @param expansions Maps simple identifiers defined in the current SELECT statement to their
+     *     expansions (used only when {@link SqlConformance#isSelectAlias()} requires it).
      * @param includeSystemVars If true include system vars in lists
      * @return Whether the node was expanded
      */
@@ -500,6 +505,7 @@ private boolean expandSelectItem(
             List<SqlNode> selectItems,
             Set<String> aliases,
             PairList<String, RelDataType> fields,
+            Map<String, SqlNode> expansions,
             boolean includeSystemVars) {
         final SqlValidatorScope selectScope;
         SqlNode expanded;
@@ -516,7 +522,7 @@ private boolean expandSelectItem(
             // parentheses-free functions such as LOCALTIME into explicit function
             // calls.
             selectScope = getSelectScope(select);
-            expanded = expandSelectExpr(selectItem, scope, select);
+            expanded = expandSelectExpr(selectItem, scope, select, expansions);
         }
         final String alias = SqlValidatorUtil.alias(selectItem, aliases.size());
 
@@ -5032,7 +5038,7 @@ protected void validateGroupClause(SqlSelect select) {
         }
 
         // Nodes in the GROUP BY clause are expressions except if they are calls
-        // to the GROUPING SETS, ROLLUP or CUBE operators; this operators are not
+        // to the GROUPING SETS, ROLLUP or CUBE operators; these operators are not
         // expressions, because they do not have a type.
         for (SqlNode node : groupList) {
             switch (node.getKind()) {
@@ -5176,6 +5182,8 @@ protected RelDataType validateSelectList(
         final List<SqlNode> expandedSelectItems = new ArrayList<>();
         final Set<String> aliases = new HashSet<>();
         final PairList<String, RelDataType> fieldList = PairList.of();
+        // Populated during select expansion when SqlConformance.isSelectAlias != UNSUPPORTED
+        final Map<String, SqlNode> expansions = new HashMap<>();
 
         for (SqlNode selectItem : selectItems) {
             if (selectItem instanceof SqlSelect) {
@@ -5196,6 +5204,7 @@ protected RelDataType validateSelectList(
                         expandedSelectItems,
                         aliases,
                         fieldList,
+                        expansions,
                         false);
             }
         }
@@ -6853,8 +6862,9 @@ public SqlLiteral resolveLiteral(SqlLiteral literal) {
         }
     }
 
-    public SqlNode expandSelectExpr(SqlNode expr, SelectScope scope, SqlSelect select) {
-        final Expander expander = new SelectExpander(this, scope, select);
+    public SqlNode expandSelectExpr(
+            SqlNode expr, SelectScope scope, SqlSelect select, Map<String, SqlNode> expansions) {
+        final Expander expander = new SelectExpander(this, scope, select, expansions);
         final SqlNode newExpr = expander.go(expr);
         if (expr != newExpr) {
             setOriginal(newExpr, expr);
@@ -7475,14 +7485,62 @@ public SqlNode visit(SqlIdentifier id) {
 
     /**
      * Converts an expression into canonical form by fully-qualifying any identifiers. For common
-     * columns in USING, it will be converted to COALESCE(A.col, B.col) AS col.
+     * columns in USING, it will be converted to COALESCE(A.col, B.col) AS col. When using a
+     * conformance that allows isSelectAlias, it expands identifiers that refer to local select
+     * expressions into the expressions themselves.
      */
     static class SelectExpander extends Expander {
         final SqlSelect select;
-
-        SelectExpander(SqlValidatorImpl validator, SelectScope scope, SqlSelect select) {
+        // Maps simple identifiers to their expansions.
+        final Map<String, SqlNode> expansions;
+        // List of identifiers that are currently being looked-up.  Used to detect
+        // circular dependencies when SqlConformance#isSelectAlias is ANY.
+        final Set<String> lookingUp;
+        @Nullable SqlNode root = null;
+
+        private SelectExpander(
+                SqlValidatorImpl validator,
+                SelectScope scope,
+                SqlSelect select,
+                Map<String, SqlNode> expansions,
+                Set<String> lookingUp) {
             super(validator, scope);
             this.select = select;
+            this.expansions = expansions;
+            this.lookingUp = lookingUp;
+        }
+
+        /**
+         * Creates an expander for the items in a SELECT list.
+         *
+         * @param validator Validator to use.
+         * @param scope Scope to lookup identifiers in.
+         * @param select Select that is being expanded.
+         * @param expansions List of expansions computed for identifiers that are defined in the
+         *     current select list and also used in the select list. Only used if {@link
+         *     SqlConformance#isSelectAlias()} requires it.
+         */
+        private SelectExpander(
+                SqlValidatorImpl validator,
+                SelectScope scope,
+                SqlSelect select,
+                Map<String, SqlNode> expansions) {
+            this(validator, scope, select, expansions, new HashSet<>());
+        }
+
+        private SelectExpander(SelectExpander expander) {
+            this(
+                    expander.validator,
+                    (SelectScope) expander.getScope(),
+                    expander.select,
+                    expander.expansions,
+                    expander.lookingUp);
+        }
+
+        @Override
+        public SqlNode go(SqlNode root) {
+            this.root = root;
+            return super.go(root);
         }
 
         @Override
@@ -7492,8 +7550,87 @@ static class SelectExpander extends Expander {
             if (node != id) {
                 return node;
             } else {
-                return super.visit(id);
+                try {
+                    return super.visit(id);
+                } catch (Exception ex) {
+                    if (!(ex instanceof CalciteContextException)) {
+                        throw ex;
+                    }
+                    String message = ex.getMessage();
+                    if (message != null && !message.contains("not found")) {
+                        throw ex;
+                    }
+                    // This point is reached only if the name lookup failed using standard rules
+                    SqlConformance.SelectAliasLookup selectAlias =
+                            validator.getConformance().isSelectAlias();
+                    if (selectAlias == SqlConformance.SelectAliasLookup.UNSUPPORTED
+                            || !id.isSimple()) {
+                        throw ex;
+                    }
+                    return expandAliases(id, (CalciteContextException) ex);
+                    // end of catch block
+                }
+            }
+        }
+
+        // Handle "SELECT expr as X, X+1 as Y"
+        // where X is not defined previously.
+        // Try to look up the item in the select list itself.
+        private SqlNode expandAliases(SqlIdentifier id, CalciteContextException ex) {
+            String name = id.getSimple();
+            if (lookingUp.contains(name)) {
+                final String dependentColumns =
+                        lookingUp.stream().map(s -> "'" + s + "'").collect(joining(", "));
+                throw validator.newValidationError(
+                        id, RESOURCE.columnIsCyclic(name, dependentColumns));
+            }
+            SqlConformance.SelectAliasLookup selectAlias =
+                    validator.getConformance().isSelectAlias();
+            // Check whether we already have an expansion for this identifier
+            @Nullable SqlNode expr = null;
+            if (expansions.containsKey(name)) {
+                expr = expansions.get(name);
+            } else {
+                final SqlNameMatcher nameMatcher = validator.catalogReader.nameMatcher();
+                int matches = 0;
+                for (SqlNode s : select.getSelectList()) {
+                    if (s == this.root
+                            && selectAlias == SqlConformance.SelectAliasLookup.LEFT_TO_RIGHT) {
+                        // Stop lookup at the current item
+                        break;
+                    }
+                    final String alias = SqlValidatorUtil.alias(s);
+                    if (alias != null && nameMatcher.matches(alias, name)) {
+                        expr = s;
+                        matches++;
+                    }
+                }
+                if (matches == 0) {
+                    // Throw the original exception
+                    throw ex;
+                } else if (matches > 1) {
+                    // More than one column has this alias.
+                    throw validator.newValidationError(id, RESOURCE.columnAmbiguous(name));
+                }
+                expr = stripAs(requireNonNull(expr, "expr"));
+            }
+            // Recursively expand the result
+            lookingUp.add(name);
+            SelectExpander expander = new SelectExpander(this);
+            final SqlNode newExpr = expander.go(expr);
+            lookingUp.remove(name);
+            if (expr != newExpr) {
+                validator.setOriginal(newExpr, expr);
+            }
+            expr = newExpr;
+            if (expr instanceof SqlIdentifier) {
+                expr = getScope().fullyQualify((SqlIdentifier) expr).identifier;
+            }
+            if (!expansions.containsKey(name)) {
+                expansions.put(name, expr);
+                validator.setOriginal(expr, id);
             }
+            return expr;
         }
     }
 
@@ -7529,11 +7666,11 @@ static class ExtendedExpander extends Expander {
                 return super.visit(id);
             }
 
+            final SelectScope selectScope = validator.getRawSelectScopeNonNull(select);
             final boolean replaceAliases = clause.shouldReplaceAliases(validator.config);
             if (!replaceAliases
                     || (clause == Clause.GROUP_BY && !aliasOrdinalExpandSet.contains(id))) {
-                final SelectScope scope = validator.getRawSelectScopeNonNull(select);
-                SqlNode node = expandCommonColumn(select, id, scope, validator);
+                SqlNode node = expandCommonColumn(select, id, selectScope, validator);
                 if (node != id) {
                     return node;
                 }
@@ -7565,6 +7702,15 @@ static class ExtendedExpander extends Expander {
                 }
             }
 
+            // expr cannot be null; in that case n = 0 would have returned
+            requireNonNull(expr, "expr");
+            if (validator.getConformance().isSelectAlias()
+                    != SqlConformance.SelectAliasLookup.UNSUPPORTED) {
+                Map<String, SqlNode> expansions = new HashMap<>();
+                final Expander expander =
+                        new SelectExpander(validator, selectScope, select, expansions);
+                expr = expander.go(expr);
+            }
             expr = stripAs(expr);
             if (expr instanceof SqlIdentifier) {
                 SqlIdentifier sid = (SqlIdentifier) expr;
@@ -8215,10 +8361,14 @@ private enum Clause {
         boolean shouldReplaceAliases(Config config) {
             switch (this) {
                 case GROUP_BY:
-                    return config.conformance().isGroupByAlias();
+                    return config.conformance().isGroupByAlias()
+                            || (config.conformance().isSelectAlias()
+                                    != SqlConformance.SelectAliasLookup.UNSUPPORTED);
 
                 case HAVING:
-                    return config.conformance().isHavingAlias();
+                    return config.conformance().isHavingAlias()
+                            || (config.conformance().isSelectAlias()
+                                    != SqlConformance.SelectAliasLookup.UNSUPPORTED);
 
                 case QUALIFY:
                     return true;
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
index 598849deb9b52..d350cc7cca6ef 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
@@ -37,6 +37,7 @@
 import org.apache.calcite.plan.RelOptRuleCall;
 import org.apache.calcite.plan.RelOptUtil;
 import org.apache.calcite.plan.RelRule;
+import org.apache.calcite.plan.Strong;
 import org.apache.calcite.plan.hep.HepPlanner;
 import org.apache.calcite.plan.hep.HepProgram;
 import org.apache.calcite.plan.hep.HepProgramBuilder;
@@ -1476,13 +1477,25 @@ private static boolean isWidening(RelDataType type, RelDataType type1) {
             }
             final int newLeftPos = requireNonNull(leftFrame.oldToNewOutputs.get(corDef.field));
             final int newRightPos = rightOutput.getValue();
-            conditions.add(
-                    relBuilder.equals(
-                            RexInputRef.of(newLeftPos, newLeftOutput),
-                            new RexInputRef(
-                                    newLeftFieldCount + newRightPos,
-                                    newRightOutput.get(newRightPos).getType())));
 
+            // Using `equals` instead of `IS NOT DISTINCT FROM` is an optimization
+            // for non-nullable fields. However, `IS NOT DISTINCT FROM` is always
+            // the correct choice in all cases.
+            if (isFieldNotNull(rightFrame.r, newRightPos)) {
+                conditions.add(
+                        relBuilder.equals(
+                                RexInputRef.of(newLeftPos, newLeftOutput),
+                                new RexInputRef(
+                                        newLeftFieldCount + newRightPos,
+                                        newRightOutput.get(newRightPos).getType())));
+            } else {
+                conditions.add(
+                        relBuilder.isNotDistinctFrom(
+                                RexInputRef.of(newLeftPos, newLeftOutput),
+                                new RexInputRef(
+                                        newLeftFieldCount + newRightPos,
+                                        newRightOutput.get(newRightPos).getType())));
+            }
             // remove this corVar from output position mapping
             corDefOutputs.remove(corDef);
         }
@@ -3287,6 +3300,61 @@ assert allLessThan(
         }
     }
 
+    /**
+     * Check if the field at the given index is non-nullable.
+     *
+     * <p>This method performs a basic check for `null` values in the field. However, a `false`
+     * result does not necessarily mean that the field contains `null` values. It only guarantees
+     * that if the result is `true`, the field contains no `null` values.
+     */
+    private static boolean isFieldNotNull(RelNode rel, int index) {
+        RelDataType type = rel.getRowType().getFieldList().get(index).getType();
+        return !type.isNullable() || isFieldNotNullRecursive(rel, index);
+    }
+
+    private static boolean isFieldNotNullRecursive(RelNode rel, int index) {
+        if (rel instanceof Project) {
+            Project project = (Project) rel;
+
+            RexNode expr = project.getProjects().get(index);
+            if (!(expr instanceof RexInputRef)) {
+                return false;
+            }
+            return isFieldNotNullRecursive(project.getInput(), ((RexInputRef) expr).getIndex());
+        } else if (rel instanceof Aggregate) {
+            Aggregate agg = (Aggregate) rel;
+            ImmutableBitSet groupSet = agg.getGroupSet();
+
+            if (index >= groupSet.size()) {
+                return false;
+            }
+            return isFieldNotNullRecursive(agg.getInput(), groupSet.asList().get(index));
+        } else if (rel instanceof Filter) {
+            Filter filter = (Filter) rel;
+            if (Strong.isNotTrue(filter.getCondition(), ImmutableBitSet.of(index))) {
+                return true;
+            }
+            return isFieldNotNullRecursive(filter.getInput(), index);
+        } else if (rel instanceof Join) {
+            Join join = (Join) rel;
+            int leftFieldCnt = join.getLeft().getRowType().getFieldCount();
+            if (index < join.getLeft().getRowType().getFieldCount()) {
+                if (!join.getJoinType().generatesNullsOnLeft()) {
+                    return Strong.isNotTrue(join.getCondition(), ImmutableBitSet.of(index))
+                            || isFieldNotNullRecursive(join.getLeft(), index);
+                }
+            } else {
+                if (!join.getJoinType().generatesNullsOnRight()) {
+                    return Strong.isNotTrue(join.getCondition(), ImmutableBitSet.of(index))
+                            || isFieldNotNullRecursive(join.getRight(), index - leftFieldCnt);
+                }
+            }
+            return false;
+        } else {
+            return false;
+        }
+    }
+
     // -------------------------------------------------------------------------
     //  Getter/Setter
     // -------------------------------------------------------------------------
diff --git a/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE b/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
index 46d96857eb13f..0688c621bf0b6 100644
--- a/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
+++ b/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
@@ -8,8 +8,8 @@ This project bundles the following dependencies under the Apache Software Licens
 
 - com.google.guava:guava:33.4.0-jre
 - com.google.guava:failureaccess:1.0.2
-- org.apache.calcite:calcite-core:1.39.0
-- org.apache.calcite:calcite-linq4j:1.39.0
+- org.apache.calcite:calcite-core:1.40.0
+- org.apache.calcite:calcite-linq4j:1.40.0
 - org.apache.calcite.avatica:avatica-core:1.26.0
 - org.apache.commons:commons-math3:3.6.1
 - org.apache.commons:commons-text:1.10.0
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DynamicFunctionPlanTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DynamicFunctionPlanTest.xml
index 37afe873a8ed6..7e420a5ab0d13 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DynamicFunctionPlanTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/DynamicFunctionPlanTest.xml
@@ -61,10 +61,11 @@ LogicalAggregate(group=[{0, 1}], EXPR$2=[SUM($2)], EXPR$3=[COUNT()])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-HashAggregate(isMerge=[false], groupBy=[cat, hh], select=[cat, hh, SUM(cnt) AS EXPR$2, COUNT(*) AS EXPR$3])
-+- Exchange(distribution=[hash[cat, hh]])
-   +- Calc(select=[cat, SUBSTR(CAST(LOCALTIME() AS VARCHAR(2147483647)), 1, 2) AS hh, cnt], where=[(SUBSTR(CAST(ts AS VARCHAR(2147483647)), 1, 2) = SUBSTR(CAST(LOCALTIME() AS VARCHAR(2147483647)), 1, 2))])
-      +- TableSourceScan(table=[[default_catalog, default_database, src, filter=[], project=[cat, cnt, ts], metadata=[]]], fields=[cat, cnt, ts])
+Calc(select=[cat, SUBSTR(CAST(LOCALTIME() AS VARCHAR(2147483647)), 1, 2) AS hh, EXPR$2, EXPR$3])
++- HashAggregate(isMerge=[false], groupBy=[cat], select=[cat, SUM(cnt) AS EXPR$2, COUNT(*) AS EXPR$3])
+   +- Exchange(distribution=[hash[cat]])
+      +- Calc(select=[cat, cnt], where=[(SUBSTR(CAST(ts AS VARCHAR(2147483647)), 1, 2) = SUBSTR(CAST(LOCALTIME() AS VARCHAR(2147483647)), 1, 2))])
+         +- TableSourceScan(table=[[default_catalog, default_database, src, filter=[], project=[cat, cnt, ts], metadata=[]]], fields=[cat, cnt, ts])
 ]]>
     </Resource>
   </TestCase>
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 1b679021b32a8..23362c44d91b1 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
@@ -490,19 +490,20 @@ 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=[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]])
-:     :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-:     +- Exchange(distribution=[hash[d]])
-:        +- Calc(select=[d, CAST(2 AS BIGINT) AS e, f], where=[(e = 2)])
-:           +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
-:- Exchange(distribution=[hash[a]])
-:  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-+- Exchange(distribution=[hash[d]])
-   +- Calc(select=[d, CAST(2 AS BIGINT) AS e, f], where=[(e = 2)])
-      +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
+Calc(select=[a, b, c, d, CAST(2 AS BIGINT) AS e, f, a0, b0, c0, d0, CAST(2 AS BIGINT) AS e0, f0])
++- MultipleInput(readOrder=[0,1,0], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, f, a0, b0, c0, d0, f0], build=[left])\n:- [#1] Exchange(distribution=[hash[a]])\n+- HashJoin(joinType=[RightOuterJoin], where=[(a = d)], select=[a, b, c, d, 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, f], build=[right])
+   :     :- Exchange(distribution=[hash[a]])
+   :     :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
+   :     +- Exchange(distribution=[hash[d]])
+   :        +- Calc(select=[d, f], where=[(e = 2)])
+   :           +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
+   :- Exchange(distribution=[hash[a]])
+   :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
+   +- Exchange(distribution=[hash[d]])
+      +- Calc(select=[d, f], where=[(e = 2)])
+         +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
 ]]>
     </Resource>
   </TestCase>
@@ -1158,19 +1159,20 @@ 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(members=[\nSortMergeJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, e, f, a0, b0, c0, d0, e0, f0])\n:- [#1] Exchange(distribution=[hash[a]])\n+- SortMergeJoin(joinType=[RightOuterJoin], where=[(a = d)], select=[a, b, c, d, e, f])\n   :- [#2] Exchange(distribution=[hash[a]])\n   +- [#3] Exchange(distribution=[hash[d]])\n])
-:- Exchange(distribution=[hash[a]])
-:  +- SortMergeJoin(joinType=[RightOuterJoin], where=[(a = d)], select=[a, b, c, d, e, f])
-:     :- Exchange(distribution=[hash[a]])
-:     :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-:     +- Exchange(distribution=[hash[d]])
-:        +- Calc(select=[d, CAST(2 AS BIGINT) AS e, f], where=[(e = 2)])
-:           +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
-:- Exchange(distribution=[hash[a]])
-:  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-+- Exchange(distribution=[hash[d]])
-   +- Calc(select=[d, CAST(2 AS BIGINT) AS e, f], where=[(e = 2)])
-      +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
+Calc(select=[a, b, c, d, CAST(2 AS BIGINT) AS e, f, a0, b0, c0, d0, CAST(2 AS BIGINT) AS e0, f0])
++- MultipleInput(members=[\nSortMergeJoin(joinType=[InnerJoin], where=[(a = d0)], select=[a, b, c, d, f, a0, b0, c0, d0, f0])\n:- [#1] Exchange(distribution=[hash[a]])\n+- SortMergeJoin(joinType=[RightOuterJoin], where=[(a = d)], select=[a, b, c, d, f])\n   :- [#2] Exchange(distribution=[hash[a]])\n   +- [#3] Exchange(distribution=[hash[d]])\n])
+   :- Exchange(distribution=[hash[a]])
+   :  +- SortMergeJoin(joinType=[RightOuterJoin], where=[(a = d)], select=[a, b, c, d, f])
+   :     :- Exchange(distribution=[hash[a]])
+   :     :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
+   :     +- Exchange(distribution=[hash[d]])
+   :        +- Calc(select=[d, f], where=[(e = 2)])
+   :           +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, source: [TestTableSource(d, e, f)]]], fields=[d, e, f])
+   :- Exchange(distribution=[hash[a]])
+   :  +- LegacyTableSourceScan(table=[[default_catalog, default_database, x, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
+   +- Exchange(distribution=[hash[d]])
+      +- Calc(select=[d, f], where=[(e = 2)])
+         +- LegacyTableSourceScan(table=[[default_catalog, default_database, y, 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/BroadcastHashJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/BroadcastHashJoinTest.xml
index 897e52cf7f783..dc0d9c3e721b3 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/BroadcastHashJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/BroadcastHashJoinTest.xml
@@ -138,14 +138,15 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, b, CAST(2 AS INTEGER) AS d, e])
-+- MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], isBroadcast=[true], build=[right])\n:- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])\n:  +- [#2] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[broadcast])\n])
+Calc(select=[CAST(2 AS INTEGER) AS a, b, CAST(2 AS INTEGER) AS d, e])
++- MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], isBroadcast=[true], build=[right])\n:- Calc(select=[b])\n:  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])\n:     +- [#2] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[broadcast])\n])
    :- Exchange(distribution=[broadcast])
-   :  +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
-   :     +- Exchange(distribution=[hash[d]])
-   :        +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-   :           +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
+   :  +- Calc(select=[e])
+   :     +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
+   :        +- Exchange(distribution=[hash[d]])
+   :           +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
+   :              +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
    +- 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)])
@@ -174,46 +175,6 @@ Calc(select=[c, g])
    +- Exchange(distribution=[broadcast])
       +- Calc(select=[d, e, g])
          +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testInnerJoinWithJoinConditionPushDown">
-    <Resource name="sql">
-      <![CDATA[
-SELECT * FROM
-   (select a, count(b) as b from MyTable1 group by a)
-   join
-   (select d, count(e) as e from MyTable2 group by d)
-   on a = d and b = e and d = 2 and b = 1
-]]>
-    </Resource>
-    <Resource name="ast">
-      <![CDATA[
-LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
-+- LogicalJoin(condition=[AND(=($0, $2), =($1, $3), =($2, 2), =($1, 1))], joinType=[inner])
-   :- LogicalAggregate(group=[{0}], b=[COUNT($1)])
-   :  +- LogicalProject(a=[$0], b=[$1])
-   :     +- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
-   +- LogicalAggregate(group=[{0}], e=[COUNT($1)])
-      +- LogicalProject(d=[$0], e=[$1])
-         +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
-]]>
-    </Resource>
-    <Resource name="optimized exec plan">
-      <![CDATA[
-Calc(select=[a, 1 AS b, CAST(2 AS INTEGER) AS d, 1 AS e])
-+- MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], isBroadcast=[true], build=[right])\n:- Calc(select=[a], where=[(b = 1)])\n:  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])\n:     +- [#2] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[broadcast])\n])
-   :- Exchange(distribution=[broadcast])
-   :  +- Calc(select=[d], where=[(e = 1)])
-   :     +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
-   :        +- Exchange(distribution=[hash[d]])
-   :           +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-   :              +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
-   +- 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)])
-            +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
 ]]>
     </Resource>
   </TestCase>
@@ -311,14 +272,15 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[CAST(2 AS INTEGER) AS a, b, d, CAST(e AS BIGINT) AS e])
-+- MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], isBroadcast=[true], build=[right])\n:- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])\n:  +- [#2] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[broadcast])\n])
+Calc(select=[CAST(2 AS INTEGER) AS a, b, CAST(2 AS INTEGER) AS d, CAST(e AS BIGINT) AS e])
++- MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], isBroadcast=[true], build=[right])\n:- Calc(select=[b])\n:  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])\n:     +- [#2] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[broadcast])\n])
    :- Exchange(distribution=[broadcast])
-   :  +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
-   :     +- Exchange(distribution=[hash[d]])
-   :        +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-   :           +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
+   :  +- Calc(select=[e])
+   :     +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
+   :        +- Exchange(distribution=[hash[d]])
+   :           +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
+   :              +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
    +- 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)])
@@ -547,14 +509,15 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, CAST(b AS BIGINT) AS b, CAST(2 AS INTEGER) AS d, e])
-+- MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], isBroadcast=[true], build=[right])\n:- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])\n:  +- [#2] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[broadcast])\n])
+Calc(select=[CAST(2 AS INTEGER) AS a, CAST(b AS BIGINT) AS b, CAST(2 AS INTEGER) AS d, e])
++- MultipleInput(readOrder=[0,1], members=[\nHashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], isBroadcast=[true], build=[right])\n:- Calc(select=[b])\n:  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])\n:     +- [#2] Exchange(distribution=[hash[a]])\n+- [#1] Exchange(distribution=[broadcast])\n])
    :- Exchange(distribution=[broadcast])
-   :  +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
-   :     +- Exchange(distribution=[hash[d]])
-   :        +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-   :           +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
+   :  +- Calc(select=[e])
+   :     +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
+   :        +- Exchange(distribution=[hash[d]])
+   :           +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
+   :              +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
    +- 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)])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/NestedLoopJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/NestedLoopJoinTest.xml
index c37f2d9eb04f6..4f6c8e1e9a445 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/NestedLoopJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/NestedLoopJoinTest.xml
@@ -324,14 +324,15 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, b, CAST(2 AS INTEGER) AS d, e])
-+- MultipleInput(readOrder=[0,1], members=[\nNestedLoopJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], build=[left])\n:- [#1] Exchange(distribution=[broadcast])\n+- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])\n   +- [#2] Exchange(distribution=[hash[d]])\n])
+Calc(select=[CAST(2 AS INTEGER) AS a, b, CAST(2 AS INTEGER) AS d, e])
++- MultipleInput(readOrder=[0,1], members=[\nNestedLoopJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])\n:- [#1] Exchange(distribution=[broadcast])\n+- Calc(select=[e])\n   +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])\n      +- [#2] Exchange(distribution=[hash[d]])\n])
    :- Exchange(distribution=[broadcast])
-   :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
-   :     +- 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)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
+   :  +- Calc(select=[b])
+   :     +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
+   :        +- 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)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
    +- Exchange(distribution=[hash[d]])
       +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
          +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
@@ -387,8 +388,8 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, 1 AS b, CAST(2 AS INTEGER) AS d, 1 AS e])
-+- MultipleInput(readOrder=[0,1], members=[\nNestedLoopJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d], build=[left])\n:- [#1] Exchange(distribution=[broadcast])\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])
+Calc(select=[CAST(2 AS INTEGER) AS a, 1 AS b, CAST(2 AS INTEGER) AS d, 1 AS e])
++- MultipleInput(readOrder=[0,1], members=[\nNestedLoopJoin(joinType=[InnerJoin], where=[true], select=[a, d], build=[left])\n:- [#1] Exchange(distribution=[broadcast])\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=[broadcast])
    :  +- Calc(select=[a], where=[(b = 1)])
    :     +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
@@ -520,14 +521,15 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[CAST(2 AS INTEGER) AS a, b, d, CAST(e AS BIGINT) AS e])
-+- MultipleInput(readOrder=[0,1], members=[\nNestedLoopJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], build=[left])\n:- [#1] Exchange(distribution=[broadcast])\n+- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])\n   +- [#2] Exchange(distribution=[hash[d]])\n])
+Calc(select=[CAST(2 AS INTEGER) AS a, b, CAST(2 AS INTEGER) AS d, CAST(e AS BIGINT) AS e])
++- MultipleInput(readOrder=[0,1], members=[\nNestedLoopJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])\n:- [#1] Exchange(distribution=[broadcast])\n+- Calc(select=[e])\n   +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])\n      +- [#2] Exchange(distribution=[hash[d]])\n])
    :- Exchange(distribution=[broadcast])
-   :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
-   :     +- 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)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
+   :  +- Calc(select=[b])
+   :     +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
+   :        +- 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)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
    +- Exchange(distribution=[hash[d]])
       +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
          +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
@@ -823,14 +825,15 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, CAST(b AS BIGINT) AS b, CAST(2 AS INTEGER) AS d, e])
-+- MultipleInput(readOrder=[0,1], members=[\nNestedLoopJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e], build=[left])\n:- [#1] Exchange(distribution=[broadcast])\n+- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])\n   +- [#2] Exchange(distribution=[hash[d]])\n])
+Calc(select=[CAST(2 AS INTEGER) AS a, CAST(b AS BIGINT) AS b, CAST(2 AS INTEGER) AS d, e])
++- MultipleInput(readOrder=[0,1], members=[\nNestedLoopJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])\n:- [#1] Exchange(distribution=[broadcast])\n+- Calc(select=[e])\n   +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])\n      +- [#2] Exchange(distribution=[hash[d]])\n])
    :- Exchange(distribution=[broadcast])
-   :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
-   :     +- 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)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
+   :  +- Calc(select=[b])
+   :     +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
+   :        +- 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)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
    +- Exchange(distribution=[hash[d]])
       +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
          +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
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 e3d85fe3193b3..1a1470c714680 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
@@ -241,20 +241,22 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <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=[left])
-   :- Exchange(distribution=[hash[a, b]])
-   :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
-   :     +- 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)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
-   +- Exchange(distribution=[hash[d, e]])
-      +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
-         +- Exchange(distribution=[hash[d]])
-            +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-               +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-                  +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
+Calc(select=[CAST(2 AS INTEGER) AS a, b, CAST(2 AS INTEGER) AS d, e])
++- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])
+   :- Exchange(distribution=[hash[b]])
+   :  +- Calc(select=[b])
+   :     +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
+   :        +- 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)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
+   +- Exchange(distribution=[hash[e]])
+      +- Calc(select=[e])
+         +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
+            +- Exchange(distribution=[hash[d]])
+               +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
+                  +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
+                     +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
 ]]>
     </Resource>
   </TestCase>
@@ -280,43 +282,6 @@ Calc(select=[c, g])
    +- Exchange(distribution=[hash[e, d]])
       +- Calc(select=[d, e, g])
          +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testInnerJoinWithJoinConditionPushDown">
-    <Resource name="sql">
-      <![CDATA[
-SELECT * FROM
-   (select a, count(b) as b from MyTable1 group by a)
-   join
-   (select d, count(e) as e from MyTable2 group by d)
-   on a = d and b = e and d = 2 and b = 1
-]]>
-    </Resource>
-    <Resource name="ast">
-      <![CDATA[
-LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
-+- LogicalJoin(condition=[AND(=($0, $2), =($1, $3), =($2, 2), =($1, 1))], joinType=[inner])
-   :- LogicalAggregate(group=[{0}], b=[COUNT($1)])
-   :  +- LogicalProject(a=[$0], b=[$1])
-   :     +- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
-   +- LogicalAggregate(group=[{0}], e=[COUNT($1)])
-      +- LogicalProject(d=[$0], e=[$1])
-         +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
-]]>
-    </Resource>
-    <Resource name="optimized exec plan">
-      <![CDATA[
-Calc(select=[a, 1 AS b, CAST(2 AS INTEGER) AS d, 1 AS e])
-+- 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)])
-   :        +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
-   +- Exchange(distribution=[hash[d]])
-      +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-         +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-            +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
 ]]>
     </Resource>
   </TestCase>
@@ -416,20 +381,22 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <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=[left])
-   :- Exchange(distribution=[hash[a, b]])
-   :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
-   :     +- 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)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
-   +- Exchange(distribution=[hash[d, e]])
-      +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
-         +- Exchange(distribution=[hash[d]])
-            +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-               +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-                  +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
+Calc(select=[CAST(2 AS INTEGER) AS a, b, CAST(2 AS INTEGER) AS d, CAST(e AS BIGINT) AS e])
++- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])
+   :- Exchange(distribution=[hash[b]])
+   :  +- Calc(select=[b])
+   :     +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
+   :        +- 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)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
+   +- Exchange(distribution=[hash[e]])
+      +- Calc(select=[e])
+         +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
+            +- Exchange(distribution=[hash[d]])
+               +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
+                  +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
+                     +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
 ]]>
     </Resource>
   </TestCase>
@@ -656,20 +623,22 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <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=[left])
-   :- Exchange(distribution=[hash[a, b]])
-   :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
-   :     +- 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)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
-   +- Exchange(distribution=[hash[d, e]])
-      +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
-         +- Exchange(distribution=[hash[d]])
-            +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-               +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-                  +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
+Calc(select=[CAST(2 AS INTEGER) AS a, CAST(b AS BIGINT) AS b, CAST(2 AS INTEGER) AS d, e])
++- HashJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e], build=[left])
+   :- Exchange(distribution=[hash[b]])
+   :  +- Calc(select=[b])
+   :     +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
+   :        +- 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)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
+   +- Exchange(distribution=[hash[e]])
+      +- Calc(select=[e])
+         +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
+            +- Exchange(distribution=[hash[d]])
+               +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
+                  +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
+                     +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.xml
index 249f17770908a..b125f43544167 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.xml
@@ -241,20 +241,22 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, b, CAST(2 AS INTEGER) AS d, e])
-+- SortMergeJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e])
-   :- Exchange(distribution=[hash[a, b]])
-   :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
-   :     +- 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)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
-   +- Exchange(distribution=[hash[d, e]])
-      +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
-         +- Exchange(distribution=[hash[d]])
-            +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-               +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-                  +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
+Calc(select=[CAST(2 AS INTEGER) AS a, b, CAST(2 AS INTEGER) AS d, e])
++- SortMergeJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e])
+   :- Exchange(distribution=[hash[b]])
+   :  +- Calc(select=[b])
+   :     +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
+   :        +- 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)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
+   +- Exchange(distribution=[hash[e]])
+      +- Calc(select=[e])
+         +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
+            +- Exchange(distribution=[hash[d]])
+               +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
+                  +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
+                     +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
 ]]>
     </Resource>
   </TestCase>
@@ -280,43 +282,6 @@ Calc(select=[c, g])
    +- Exchange(distribution=[hash[e, d]])
       +- Calc(select=[d, e, g])
          +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testInnerJoinWithJoinConditionPushDown">
-    <Resource name="sql">
-      <![CDATA[
-SELECT * FROM
-   (select a, count(b) as b from MyTable1 group by a)
-   join
-   (select d, count(e) as e from MyTable2 group by d)
-   on a = d and b = e and d = 2 and b = 1
-]]>
-    </Resource>
-    <Resource name="ast">
-      <![CDATA[
-LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
-+- LogicalJoin(condition=[AND(=($0, $2), =($1, $3), =($2, 2), =($1, 1))], joinType=[inner])
-   :- LogicalAggregate(group=[{0}], b=[COUNT($1)])
-   :  +- LogicalProject(a=[$0], b=[$1])
-   :     +- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
-   +- LogicalAggregate(group=[{0}], e=[COUNT($1)])
-      +- LogicalProject(d=[$0], e=[$1])
-         +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
-]]>
-    </Resource>
-    <Resource name="optimized exec plan">
-      <![CDATA[
-Calc(select=[a, 1 AS b, CAST(2 AS INTEGER) AS d, 1 AS e])
-+- MultipleInput(members=[\nSortMergeJoin(joinType=[InnerJoin], where=[(a = d)], select=[a, d])\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)])
-   :        +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
-   +- Exchange(distribution=[hash[d]])
-      +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-         +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-            +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
 ]]>
     </Resource>
   </TestCase>
@@ -416,20 +381,22 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[CAST(2 AS INTEGER) AS a, b, d, CAST(e AS BIGINT) AS e])
-+- SortMergeJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e])
-   :- Exchange(distribution=[hash[a, b]])
-   :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
-   :     +- 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)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
-   +- Exchange(distribution=[hash[d, e]])
-      +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
-         +- Exchange(distribution=[hash[d]])
-            +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-               +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-                  +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
+Calc(select=[CAST(2 AS INTEGER) AS a, b, CAST(2 AS INTEGER) AS d, CAST(e AS BIGINT) AS e])
++- SortMergeJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e])
+   :- Exchange(distribution=[hash[b]])
+   :  +- Calc(select=[b])
+   :     +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
+   :        +- 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)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
+   +- Exchange(distribution=[hash[e]])
+      +- Calc(select=[e])
+         +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
+            +- Exchange(distribution=[hash[d]])
+               +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
+                  +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
+                     +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
 ]]>
     </Resource>
   </TestCase>
@@ -656,20 +623,22 @@ LogicalProject(a=[$0], b=[$1], d=[$2], e=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, CAST(b AS BIGINT) AS b, CAST(2 AS INTEGER) AS d, e])
-+- SortMergeJoin(joinType=[InnerJoin], where=[((a = d) AND (b = e))], select=[a, b, d, e])
-   :- Exchange(distribution=[hash[a, b]])
-   :  +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
-   :     +- 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)])
-   :              +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
-   +- Exchange(distribution=[hash[d, e]])
-      +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
-         +- Exchange(distribution=[hash[d]])
-            +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
-               +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
-                  +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
+Calc(select=[CAST(2 AS INTEGER) AS a, CAST(b AS BIGINT) AS b, CAST(2 AS INTEGER) AS d, e])
++- SortMergeJoin(joinType=[InnerJoin], where=[(b = e)], select=[b, e])
+   :- Exchange(distribution=[hash[b]])
+   :  +- Calc(select=[b])
+   :     +- HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_COUNT(count$0) AS b])
+   :        +- 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)])
+   :                 +- TableSourceScan(table=[[default_catalog, default_database, MyTable1]], fields=[a, b, c])
+   +- Exchange(distribution=[hash[e]])
+      +- Calc(select=[e])
+         +- HashAggregate(isMerge=[true], groupBy=[d], select=[d, Final_COUNT(count$0) AS e])
+            +- Exchange(distribution=[hash[d]])
+               +- LocalHashAggregate(groupBy=[d], select=[d, Partial_COUNT(e) AS count$0])
+                  +- Calc(select=[CAST(2 AS INTEGER) AS d, e], where=[(d = 2)])
+                     +- TableSourceScan(table=[[default_catalog, default_database, MyTable2]], fields=[d, e, f, g, h])
 ]]>
     </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 9bf2749be2a02..e27a64aecca3b 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
@@ -394,27 +394,26 @@ LogicalProject(EXPR$0=[+($0, $cor0.a1)])
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1])
-+- HashJoin(joinType=[InnerJoin], where=[=(a1, a10)], select=[a1, b1, a10], build=[left])
-   :- Exchange(distribution=[hash[a1]])
++- HashJoin(joinType=[InnerJoin], where=[AND(IS NOT DISTINCT FROM(a1, a10), =(a1, EXPR$0))], select=[a1, b1, EXPR$0, a10], build=[left])
+   :- Exchange(distribution=[hash[a1, a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
-   +- Exchange(distribution=[hash[a1]])
-      +- Calc(select=[a1])
-         +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-            +- Exchange(distribution=[hash[EXPR$0, a1]])
-               +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-                  +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
-                     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a1, +(a2, a1))], select=[a2, a1], build=[right])
-                        :- Calc(select=[a2])
-                        :  +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], isBroadcast=[true], build=[left])
-                        :     :- Exchange(distribution=[broadcast])
-                        :     :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
-                        :     +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
-                        +- Exchange(distribution=[broadcast])
-                           +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
-                              +- Exchange(distribution=[hash[a1]])
-                                 +- LocalHashAggregate(groupBy=[a1], select=[a1])
-                                    +- Calc(select=[a1])
-                                       +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
+   +- Exchange(distribution=[hash[a1, EXPR$0]])
+      +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+         +- Exchange(distribution=[hash[EXPR$0, a1]])
+            +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+               +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
+                  +- NestedLoopJoin(joinType=[InnerJoin], where=[true], select=[a2, a1], build=[right])
+                     :- Calc(select=[a2])
+                     :  +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], isBroadcast=[true], build=[left])
+                     :     :- Exchange(distribution=[broadcast])
+                     :     :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
+                     :     +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
+                     +- Exchange(distribution=[broadcast])
+                        +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
+                           +- Exchange(distribution=[hash[a1]])
+                              +- LocalHashAggregate(groupBy=[a1], select=[a1])
+                                 +- Calc(select=[a1])
+                                    +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
 ]]>
     </Resource>
   </TestCase>
@@ -474,32 +473,31 @@ LogicalProject(EXPR$0=[+($0, $cor0.a1)])
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1])
-+- HashJoin(joinType=[InnerJoin], where=[=(a1, a10)], select=[a1, b1, a10], build=[left])
-   :- Exchange(distribution=[hash[a1]])
++- HashJoin(joinType=[InnerJoin], where=[AND(IS NOT DISTINCT FROM(a1, a10), =(a1, EXPR$0))], select=[a1, b1, EXPR$0, a10], build=[left])
+   :- Exchange(distribution=[hash[a1, a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
-   +- Exchange(distribution=[hash[a1]])
-      +- Calc(select=[a1])
-         +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-            +- Exchange(distribution=[hash[EXPR$0, a1]])
-               +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-                  +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
-                     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a1, +(a2, a1))], select=[a2, a1], build=[right])
-                        :- Calc(select=[a2])
-                        :  +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], isBroadcast=[true], build=[left])
-                        :     :- 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=[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]])
-                        :              +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
-                        +- Exchange(distribution=[broadcast])
-                           +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
-                              +- Exchange(distribution=[hash[a1]])
-                                 +- LocalHashAggregate(groupBy=[a1], select=[a1])
-                                    +- Calc(select=[a1])
-                                       +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
+   +- Exchange(distribution=[hash[a1, EXPR$0]])
+      +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+         +- Exchange(distribution=[hash[EXPR$0, a1]])
+            +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+               +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
+                  +- NestedLoopJoin(joinType=[InnerJoin], where=[true], select=[a2, a1], build=[right])
+                     :- Calc(select=[a2])
+                     :  +- HashJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], isBroadcast=[true], build=[left])
+                     :     :- 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=[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]])
+                     :              +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
+                     +- Exchange(distribution=[broadcast])
+                        +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
+                           +- Exchange(distribution=[hash[a1]])
+                              +- LocalHashAggregate(groupBy=[a1], select=[a1])
+                                 +- Calc(select=[a1])
+                                    +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
 ]]>
     </Resource>
   </TestCase>
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 ee97a0df7bf9d..a742cb4f34325 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
@@ -394,27 +394,26 @@ LogicalProject(EXPR$0=[+($0, $cor0.a1)])
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1])
-+- HashJoin(joinType=[InnerJoin], where=[=(a1, a10)], select=[a1, b1, a10], build=[left])
-   :- Exchange(distribution=[hash[a1]])
++- HashJoin(joinType=[InnerJoin], where=[AND(IS NOT DISTINCT FROM(a1, a10), =(a1, EXPR$0))], select=[a1, b1, EXPR$0, a10], build=[left])
+   :- Exchange(distribution=[hash[a1, a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
-   +- Exchange(distribution=[hash[a1]])
-      +- Calc(select=[a1])
-         +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-            +- Exchange(distribution=[hash[EXPR$0, a1]])
-               +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-                  +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
-                     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a1, +(a2, a1))], select=[a2, a1], build=[left])
-                        :- Exchange(distribution=[broadcast])
-                        :  +- Calc(select=[a2])
-                        :     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[left])
-                        :        :- Exchange(distribution=[broadcast])
-                        :        :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
-                        :        +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
-                        +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
-                           +- Exchange(distribution=[hash[a1]])
-                              +- LocalHashAggregate(groupBy=[a1], select=[a1])
-                                 +- Calc(select=[a1])
-                                    +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
+   +- Exchange(distribution=[hash[a1, EXPR$0]])
+      +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+         +- Exchange(distribution=[hash[EXPR$0, a1]])
+            +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+               +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
+                  +- NestedLoopJoin(joinType=[InnerJoin], where=[true], select=[a2, a1], build=[left])
+                     :- Exchange(distribution=[broadcast])
+                     :  +- Calc(select=[a2])
+                     :     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[left])
+                     :        :- Exchange(distribution=[broadcast])
+                     :        :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
+                     :        +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
+                     +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
+                        +- Exchange(distribution=[hash[a1]])
+                           +- LocalHashAggregate(groupBy=[a1], select=[a1])
+                              +- Calc(select=[a1])
+                                 +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
 ]]>
     </Resource>
   </TestCase>
@@ -474,32 +473,31 @@ LogicalProject(EXPR$0=[+($0, $cor0.a1)])
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1])
-+- HashJoin(joinType=[InnerJoin], where=[=(a1, a10)], select=[a1, b1, a10], build=[left])
-   :- Exchange(distribution=[hash[a1]])
++- HashJoin(joinType=[InnerJoin], where=[AND(IS NOT DISTINCT FROM(a1, a10), =(a1, EXPR$0))], select=[a1, b1, EXPR$0, a10], build=[left])
+   :- Exchange(distribution=[hash[a1, a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
-   +- Exchange(distribution=[hash[a1]])
-      +- Calc(select=[a1])
-         +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-            +- Exchange(distribution=[hash[EXPR$0, a1]])
-               +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-                  +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
-                     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a1, +(a2, a1))], select=[a2, a1], build=[left])
-                        :- Exchange(distribution=[broadcast])
-                        :  +- Calc(select=[a2])
-                        :     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[left])
-                        :        :- 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=[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]])
-                        :                 +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
-                        +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
-                           +- Exchange(distribution=[hash[a1]])
-                              +- LocalHashAggregate(groupBy=[a1], select=[a1])
-                                 +- Calc(select=[a1])
-                                    +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
+   +- Exchange(distribution=[hash[a1, EXPR$0]])
+      +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+         +- Exchange(distribution=[hash[EXPR$0, a1]])
+            +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+               +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
+                  +- NestedLoopJoin(joinType=[InnerJoin], where=[true], select=[a2, a1], build=[left])
+                     :- Exchange(distribution=[broadcast])
+                     :  +- Calc(select=[a2])
+                     :     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3], build=[left])
+                     :        :- 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=[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]])
+                     :                 +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
+                     +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
+                        +- Exchange(distribution=[hash[a1]])
+                           +- LocalHashAggregate(groupBy=[a1], select=[a1])
+                              +- Calc(select=[a1])
+                                 +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
 ]]>
     </Resource>
   </TestCase>
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 2e2911591ea2a..e13fa7b305af7 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
@@ -400,28 +400,27 @@ LogicalProject(EXPR$0=[+($0, $cor0.a1)])
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1])
-+- HashJoin(joinType=[InnerJoin], where=[=(a1, a10)], select=[a1, b1, a10], build=[left])
-   :- Exchange(distribution=[hash[a1]])
++- HashJoin(joinType=[InnerJoin], where=[AND(IS NOT DISTINCT FROM(a1, a10), =(a1, EXPR$0))], select=[a1, b1, EXPR$0, a10], build=[left])
+   :- Exchange(distribution=[hash[a1, a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
-   +- Exchange(distribution=[hash[a1]])
-      +- Calc(select=[a1])
-         +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-            +- Exchange(distribution=[hash[EXPR$0, a1]])
-               +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-                  +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
-                     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a1, +(a2, a1))], select=[a2, a1], build=[right])
-                        :- Calc(select=[a2])
-                        :  +- 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]])
-                        :        +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
-                        +- Exchange(distribution=[broadcast])
-                           +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
-                              +- Exchange(distribution=[hash[a1]])
-                                 +- LocalHashAggregate(groupBy=[a1], select=[a1])
-                                    +- Calc(select=[a1])
-                                       +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
+   +- Exchange(distribution=[hash[a1, EXPR$0]])
+      +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+         +- Exchange(distribution=[hash[EXPR$0, a1]])
+            +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+               +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
+                  +- NestedLoopJoin(joinType=[InnerJoin], where=[true], select=[a2, a1], build=[right])
+                     :- Calc(select=[a2])
+                     :  +- 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]])
+                     :        +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
+                     +- Exchange(distribution=[broadcast])
+                        +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
+                           +- Exchange(distribution=[hash[a1]])
+                              +- LocalHashAggregate(groupBy=[a1], select=[a1])
+                                 +- Calc(select=[a1])
+                                    +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
 ]]>
     </Resource>
   </TestCase>
@@ -482,32 +481,31 @@ LogicalProject(EXPR$0=[+($0, $cor0.a1)])
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1])
-+- HashJoin(joinType=[InnerJoin], where=[=(a1, a10)], select=[a1, b1, a10], build=[left])
-   :- Exchange(distribution=[hash[a1]])
++- HashJoin(joinType=[InnerJoin], where=[AND(IS NOT DISTINCT FROM(a1, a10), =(a1, EXPR$0))], select=[a1, b1, EXPR$0, a10], build=[left])
+   :- Exchange(distribution=[hash[a1, a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
-   +- Exchange(distribution=[hash[a1]])
-      +- Calc(select=[a1])
-         +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-            +- Exchange(distribution=[hash[EXPR$0, a1]])
-               +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-                  +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
-                     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a1, +(a2, a1))], select=[a2, a1], build=[right])
-                        :- Calc(select=[a2])
-                        :  +- 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]]]])
-                        :     +- Calc(select=[a3])
-                        :        +- 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]])
-                        :              +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
-                        +- Exchange(distribution=[broadcast])
-                           +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
-                              +- Exchange(distribution=[hash[a1]])
-                                 +- LocalHashAggregate(groupBy=[a1], select=[a1])
-                                    +- Calc(select=[a1])
-                                       +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
+   +- Exchange(distribution=[hash[a1, EXPR$0]])
+      +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+         +- Exchange(distribution=[hash[EXPR$0, a1]])
+            +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+               +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
+                  +- NestedLoopJoin(joinType=[InnerJoin], where=[true], select=[a2, a1], build=[right])
+                     :- Calc(select=[a2])
+                     :  +- 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]]]])
+                     :     +- Calc(select=[a3])
+                     :        +- 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]])
+                     :              +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
+                     +- Exchange(distribution=[broadcast])
+                        +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
+                           +- Exchange(distribution=[hash[a1]])
+                              +- LocalHashAggregate(groupBy=[a1], select=[a1])
+                                 +- Calc(select=[a1])
+                                    +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
 ]]>
     </Resource>
   </TestCase>
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 f89c07d64f3ea..0a109d76f95ee 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
@@ -400,28 +400,27 @@ LogicalProject(EXPR$0=[+($0, $cor0.a1)])
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1])
-+- HashJoin(joinType=[InnerJoin], where=[=(a1, a10)], select=[a1, b1, a10], build=[left])
-   :- Exchange(distribution=[hash[a1]])
++- HashJoin(joinType=[InnerJoin], where=[AND(IS NOT DISTINCT FROM(a1, a10), =(a1, EXPR$0))], select=[a1, b1, EXPR$0, a10], build=[left])
+   :- Exchange(distribution=[hash[a1, a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
-   +- Exchange(distribution=[hash[a1]])
-      +- Calc(select=[a1])
-         +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-            +- Exchange(distribution=[hash[EXPR$0, a1]])
-               +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-                  +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
-                     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a1, +(a2, a1))], select=[a2, a1], build=[right])
-                        :- Calc(select=[a2])
-                        :  +- SortMergeJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3])
-                        :     :- Exchange(distribution=[hash[a2]])
-                        :     :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
-                        :     +- Exchange(distribution=[hash[a3]])
-                        :        +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
-                        +- Exchange(distribution=[broadcast])
-                           +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
-                              +- Exchange(distribution=[hash[a1]])
-                                 +- LocalHashAggregate(groupBy=[a1], select=[a1])
-                                    +- Calc(select=[a1])
-                                       +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
+   +- Exchange(distribution=[hash[a1, EXPR$0]])
+      +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+         +- Exchange(distribution=[hash[EXPR$0, a1]])
+            +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+               +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
+                  +- NestedLoopJoin(joinType=[InnerJoin], where=[true], select=[a2, a1], build=[right])
+                     :- Calc(select=[a2])
+                     :  +- SortMergeJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3])
+                     :     :- Exchange(distribution=[hash[a2]])
+                     :     :  +- TableSourceScan(table=[[default_catalog, default_database, T2, project=[a2], metadata=[]]], fields=[a2], hints=[[[ALIAS options:[T2]]]])
+                     :     +- Exchange(distribution=[hash[a3]])
+                     :        +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
+                     +- Exchange(distribution=[broadcast])
+                        +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
+                           +- Exchange(distribution=[hash[a1]])
+                              +- LocalHashAggregate(groupBy=[a1], select=[a1])
+                                 +- Calc(select=[a1])
+                                    +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
 ]]>
     </Resource>
   </TestCase>
@@ -482,32 +481,31 @@ LogicalProject(EXPR$0=[+($0, $cor0.a1)])
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[a1, b1])
-+- HashJoin(joinType=[InnerJoin], where=[=(a1, a10)], select=[a1, b1, a10], build=[left])
-   :- Exchange(distribution=[hash[a1]])
++- HashJoin(joinType=[InnerJoin], where=[AND(IS NOT DISTINCT FROM(a1, a10), =(a1, EXPR$0))], select=[a1, b1, EXPR$0, a10], build=[left])
+   :- Exchange(distribution=[hash[a1, a1]])
    :  +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
-   +- Exchange(distribution=[hash[a1]])
-      +- Calc(select=[a1])
-         +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-            +- Exchange(distribution=[hash[EXPR$0, a1]])
-               +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
-                  +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
-                     +- NestedLoopJoin(joinType=[InnerJoin], where=[=(a1, +(a2, a1))], select=[a2, a1], build=[right])
-                        :- Calc(select=[a2])
-                        :  +- SortMergeJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3])
-                        :     :- 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=[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]])
-                        :              +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
-                        +- Exchange(distribution=[broadcast])
-                           +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
-                              +- Exchange(distribution=[hash[a1]])
-                                 +- LocalHashAggregate(groupBy=[a1], select=[a1])
-                                    +- Calc(select=[a1])
-                                       +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
+   +- Exchange(distribution=[hash[a1, EXPR$0]])
+      +- HashAggregate(isMerge=[true], groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+         +- Exchange(distribution=[hash[EXPR$0, a1]])
+            +- LocalHashAggregate(groupBy=[EXPR$0, a1], select=[EXPR$0, a1])
+               +- Calc(select=[+(a2, a1) AS EXPR$0, a1])
+                  +- NestedLoopJoin(joinType=[InnerJoin], where=[true], select=[a2, a1], build=[right])
+                     :- Calc(select=[a2])
+                     :  +- SortMergeJoin(joinType=[InnerJoin], where=[=(a2, a3)], select=[a2, a3])
+                     :     :- 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=[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]])
+                     :              +- TableSourceScan(table=[[default_catalog, default_database, T3, project=[a3], metadata=[]]], fields=[a3], hints=[[[ALIAS options:[T3]]]])
+                     +- Exchange(distribution=[broadcast])
+                        +- HashAggregate(isMerge=[true], groupBy=[a1], select=[a1])
+                           +- Exchange(distribution=[hash[a1]])
+                              +- LocalHashAggregate(groupBy=[a1], select=[a1])
+                                 +- Calc(select=[a1])
+                                    +- TableSourceScan(table=[[default_catalog, default_database, T1, project=[a1, b1], metadata=[]]], fields=[a1, b1])
 ]]>
     </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 0e508ef7691de..aa0a43e59b279 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
@@ -517,12 +517,10 @@ LogicalProject(a=[$0], c=[$2], c0=[$9])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, c, c0])
-+- 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}]]])
+Calc(select=[a, CAST('1' AS VARCHAR(2147483647)) AS c, CAST('1' AS VARCHAR(2147483647)) AS c0])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, a0], build=[left])
+   :- 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}]]])(reuse_id=[1])
    +- Exchange(distribution=[hash[a]], shuffle_mode=[BATCH])
       +- Reused(reference_id=[1])
 ]]>
@@ -767,10 +765,10 @@ LogicalProject(a=[$0], b=[$1], c=[$9])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, b, c])
-+- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, a0, c], build=[left])
+Calc(select=[a, CAST(2 AS BIGINT) AS b, c])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, a0, c], build=[left])
    :- Exchange(distribution=[hash[a]])
-   :  +- Calc(select=[a, CAST(2 AS BIGINT) AS b], where=[(b = 2)])
+   :  +- Calc(select=[a], where=[(b = 2)])
    :     +- TableSourceScan(table=[[default_catalog, default_database, MyTable, filter=[], project=[a, b, c], metadata=[]]], fields=[a, b, c])(reuse_id=[1])
    +- Exchange(distribution=[hash[a]])
       +- Calc(select=[a, c], where=[(b = 3)])
@@ -801,10 +799,10 @@ LogicalProject(a=[$0], b=[$1], c=[$10])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, b, c])
-+- Join(joinType=[InnerJoin], where=[(a = a0)], select=[a, b, a0, c], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
+Calc(select=[a, CAST(2 AS BIGINT) AS b, c])
++- Join(joinType=[InnerJoin], where=[(a = a0)], select=[a, a0, c], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
    :- Exchange(distribution=[hash[a]])
-   :  +- Calc(select=[a, CAST(2 AS BIGINT) AS b], where=[(b = 2)])
+   :  +- Calc(select=[a], where=[(b = 2)])
    :     +- TableSourceScan(table=[[default_catalog, default_database, MyTable, project=[a, b, c, nested_s], metadata=[], watermark=[-(TO_TIMESTAMP(c, nested_s), 5000:INTERVAL SECOND)], watermarkEmitStrategy=[on-periodic], filter=[]]], fields=[a, b, c, nested_s])(reuse_id=[1])
    +- Exchange(distribution=[hash[a]])
       +- Calc(select=[a, c], where=[(b = 3)])
@@ -1196,8 +1194,8 @@ LogicalProject(a=[$0], c=[$2], c0=[$9])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a, c, c0])
-+- 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])
+Calc(select=[a, CAST('1' AS VARCHAR(2147483647)) AS c, CAST('2' AS VARCHAR(2147483647)) AS c0])
++- HashJoin(joinType=[InnerJoin], where=[(a = a0)], select=[a, a0], build=[left])
    :- 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/rules/logical/JoinConditionTypeCoerceRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/JoinConditionTypeCoerceRuleTest.xml
index b578e1d34ad12..66834c9c009fa 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/JoinConditionTypeCoerceRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/JoinConditionTypeCoerceRuleTest.xml
@@ -251,7 +251,7 @@ LogicalProject(t4b=[$1])
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(t3a=[$0], t3b=[$1]), rowType=[RecordType(VARCHAR(2147483647) t3a, SMALLINT t3b)]
-+- LogicalJoin(condition=[AND(=($0, $4), =($1, $5), =($2, CAST($3):INTEGER))], joinType=[inner]), rowType=[RecordType(VARCHAR(2147483647) t3a, SMALLINT t3b, INTEGER t3c, SMALLINT t4b, VARCHAR(2147483647) t3a0, SMALLINT t3b0)]
++- LogicalJoin(condition=[AND(IS NOT DISTINCT FROM($0, $4), IS NOT DISTINCT FROM($1, $5), =($2, CAST($3):INTEGER))], joinType=[inner]), rowType=[RecordType(VARCHAR(2147483647) t3a, SMALLINT t3b, INTEGER t3c, SMALLINT t4b, VARCHAR(2147483647) t3a0, SMALLINT t3b0)]
    :- LogicalTableScan(table=[[default_catalog, default_database, T3]]), rowType=[RecordType(VARCHAR(2147483647) t3a, SMALLINT t3b, INTEGER t3c)]
    +- LogicalAggregate(group=[{0, 1, 2}]), rowType=[RecordType(SMALLINT t4b, VARCHAR(2147483647) t3a, SMALLINT t3b)]
       +- LogicalProject(t4b=[$1], t3a=[$3], t3b=[$4]), rowType=[RecordType(SMALLINT t4b, VARCHAR(2147483647) t3a, SMALLINT t3b)]
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyJoinConditionRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyJoinConditionRuleTest.xml
index 7a97b2ab03257..ec5e4f7f1516e 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyJoinConditionRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyJoinConditionRuleTest.xml
@@ -59,7 +59,7 @@ LogicalAggregate(group=[{}], EXPR$0=[COUNT()])
       <![CDATA[
 LogicalProject(a=[$0])
 +- LogicalFilter(condition=[=($1, CASE(IS NULL($5), 0:BIGINT, $5))])
-   +- LogicalJoin(condition=[AND(=($0, $3), =($1, $4))], joinType=[left])
+   +- LogicalJoin(condition=[AND(=($0, $3), IS NOT DISTINCT FROM($1, $4))], joinType=[left])
       :- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
       +- LogicalAggregate(group=[{0, 1}], EXPR$0=[COUNT()])
          +- LogicalProject(a=[$3], b=[$4])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubqueryCorrelateVariablesValidationTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubqueryCorrelateVariablesValidationTest.xml
index b549440645381..8ed7ccc7f278b 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubqueryCorrelateVariablesValidationTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubqueryCorrelateVariablesValidationTest.xml
@@ -146,7 +146,7 @@ LogicalAggregate(group=[{}], EXPR$0=[MIN($0)])
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(min_t1d=[$10])
-+- LogicalJoin(condition=[=($3, $9)], joinType=[left])
++- LogicalJoin(condition=[IS NOT DISTINCT FROM($3, $9)], joinType=[left])
    :- LogicalFilter(condition=[=($0, _UTF-16LE'test')])
    :  +- LogicalTableScan(table=[[default_catalog, default_database, t1]])
    +- LogicalAggregate(group=[{0}], EXPR$0=[MIN($1)])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/join/JoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/join/JoinTest.xml
index eeebf3f02d893..bee054a0dfceb 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/join/JoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/join/JoinTest.xml
@@ -427,18 +427,20 @@ LogicalProject(a1=[$0], a2=[$1], b1=[$2], b2=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a1, a2, CAST(2 AS INTEGER) AS b1, b2])
-+- Join(joinType=[InnerJoin], where=[((a1 = b1) AND (a2 = b2))], select=[a1, a2, b1, b2], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
-   :- Exchange(distribution=[hash[a1, a2]])
-   :  +- GroupAggregate(groupBy=[a1], select=[a1, COUNT(a2) AS a2])
-   :     +- Exchange(distribution=[hash[a1]])
-   :        +- Calc(select=[CAST(2 AS INTEGER) AS a1, a2], where=[(a1 = 2)])
-   :           +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a1, a2, a3])
-   +- Exchange(distribution=[hash[b1, b2]])
-      +- GroupAggregate(groupBy=[b1], select=[b1, COUNT(b2) AS b2])
-         +- Exchange(distribution=[hash[b1]])
-            +- Calc(select=[CAST(2 AS INTEGER) AS b1, b2], where=[(b1 = 2)])
-               +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[b1, b2, b3])
+Calc(select=[CAST(2 AS INTEGER) AS a1, a2, CAST(2 AS INTEGER) AS b1, b2])
++- Join(joinType=[InnerJoin], where=[(a2 = b2)], select=[a2, b2], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
+   :- Exchange(distribution=[hash[a2]])
+   :  +- Calc(select=[a2])
+   :     +- GroupAggregate(groupBy=[a1], select=[a1, COUNT(a2) AS a2])
+   :        +- Exchange(distribution=[hash[a1]])
+   :           +- Calc(select=[CAST(2 AS INTEGER) AS a1, a2], where=[(a1 = 2)])
+   :              +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a1, a2, a3])
+   +- Exchange(distribution=[hash[b2]])
+      +- Calc(select=[b2])
+         +- GroupAggregate(groupBy=[b1], select=[b1, COUNT(b2) AS b2])
+            +- Exchange(distribution=[hash[b1]])
+               +- Calc(select=[CAST(2 AS INTEGER) AS b1, b2], where=[(b1 = 2)])
+                  +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[b1, b2, b3])
 ]]>
     </Resource>
   </TestCase>
@@ -467,15 +469,15 @@ LogicalProject(a1=[$0], a2=[$1], b1=[$2], b2=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a1, 1 AS a2, CAST(2 AS INTEGER) AS b1, 1 AS b2])
-+- Join(joinType=[InnerJoin], where=[(a1 = b1)], select=[a1, b1], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
-   :- Exchange(distribution=[hash[a1]])
+Calc(select=[CAST(2 AS INTEGER) AS a1, 1 AS a2, CAST(2 AS INTEGER) AS b1, 1 AS b2])
++- Join(joinType=[InnerJoin], where=[true], select=[a1, b1], leftInputSpec=[HasUniqueKey], rightInputSpec=[HasUniqueKey])
+   :- Exchange(distribution=[single])
    :  +- Calc(select=[a1], where=[(a2 = 1)])
    :     +- GroupAggregate(groupBy=[a1], select=[a1, COUNT(a2) AS a2])
    :        +- Exchange(distribution=[hash[a1]])
    :           +- Calc(select=[CAST(2 AS INTEGER) AS a1, a2], where=[(a1 = 2)])
    :              +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a1, a2, a3])
-   +- Exchange(distribution=[hash[b1]])
+   +- Exchange(distribution=[single])
       +- Calc(select=[b1], where=[(b2 = 1)])
          +- GroupAggregate(groupBy=[b1], select=[b1, COUNT(b2) AS b2])
             +- Exchange(distribution=[hash[b1]])
@@ -1016,18 +1018,20 @@ LogicalProject(a1=[$0], a2=[$1], b1=[$2], b2=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[CAST(2 AS INTEGER) AS a1, a2, b1, CAST(b2 AS BIGINT) AS b2])
-+- Join(joinType=[InnerJoin], where=[((a1 = b1) AND (b2 = a2))], select=[a1, a2, b1, b2], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
-   :- Exchange(distribution=[hash[a1, a2]])
-   :  +- GroupAggregate(groupBy=[a1], select=[a1, COUNT(a2) AS a2])
-   :     +- Exchange(distribution=[hash[a1]])
-   :        +- Calc(select=[CAST(2 AS INTEGER) AS a1, a2], where=[(a1 = 2)])
-   :           +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a1, a2, a3])
-   +- Exchange(distribution=[hash[b1, b2]])
-      +- GroupAggregate(groupBy=[b1], select=[b1, COUNT(b2) AS b2])
-         +- Exchange(distribution=[hash[b1]])
-            +- Calc(select=[CAST(2 AS INTEGER) AS b1, b2], where=[(b1 = 2)])
-               +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[b1, b2, b3])
+Calc(select=[CAST(2 AS INTEGER) AS a1, a2, CAST(2 AS INTEGER) AS b1, CAST(b2 AS BIGINT) AS b2])
++- Join(joinType=[InnerJoin], where=[(b2 = a2)], select=[a2, b2], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
+   :- Exchange(distribution=[hash[a2]])
+   :  +- Calc(select=[a2])
+   :     +- GroupAggregate(groupBy=[a1], select=[a1, COUNT(a2) AS a2])
+   :        +- Exchange(distribution=[hash[a1]])
+   :           +- Calc(select=[CAST(2 AS INTEGER) AS a1, a2], where=[(a1 = 2)])
+   :              +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a1, a2, a3])
+   +- Exchange(distribution=[hash[b2]])
+      +- Calc(select=[b2])
+         +- GroupAggregate(groupBy=[b1], select=[b1, COUNT(b2) AS b2])
+            +- Exchange(distribution=[hash[b1]])
+               +- Calc(select=[CAST(2 AS INTEGER) AS b1, b2], where=[(b1 = 2)])
+                  +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[b1, b2, b3])
 ]]>
     </Resource>
   </TestCase>
@@ -1423,18 +1427,20 @@ LogicalProject(a1=[$0], a2=[$1], b1=[$2], b2=[$3])
     </Resource>
     <Resource name="optimized exec plan">
       <![CDATA[
-Calc(select=[a1, CAST(a2 AS BIGINT) AS a2, CAST(2 AS INTEGER) AS b1, b2])
-+- Join(joinType=[InnerJoin], where=[((a1 = b1) AND (a2 = b2))], select=[a1, a2, b1, b2], leftInputSpec=[JoinKeyContainsUniqueKey], rightInputSpec=[JoinKeyContainsUniqueKey])
-   :- Exchange(distribution=[hash[a1, a2]])
-   :  +- GroupAggregate(groupBy=[a1], select=[a1, COUNT(a2) AS a2])
-   :     +- Exchange(distribution=[hash[a1]])
-   :        +- Calc(select=[CAST(2 AS INTEGER) AS a1, a2], where=[(a1 = 2)])
-   :           +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a1, a2, a3])
-   +- Exchange(distribution=[hash[b1, b2]])
-      +- GroupAggregate(groupBy=[b1], select=[b1, COUNT(b2) AS b2])
-         +- Exchange(distribution=[hash[b1]])
-            +- Calc(select=[CAST(2 AS INTEGER) AS b1, b2], where=[(b1 = 2)])
-               +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[b1, b2, b3])
+Calc(select=[CAST(2 AS INTEGER) AS a1, CAST(a2 AS BIGINT) AS a2, CAST(2 AS INTEGER) AS b1, b2])
++- Join(joinType=[InnerJoin], where=[(a2 = b2)], select=[a2, b2], leftInputSpec=[NoUniqueKey], rightInputSpec=[NoUniqueKey])
+   :- Exchange(distribution=[hash[a2]])
+   :  +- Calc(select=[a2])
+   :     +- GroupAggregate(groupBy=[a1], select=[a1, COUNT(a2) AS a2])
+   :        +- Exchange(distribution=[hash[a1]])
+   :           +- Calc(select=[CAST(2 AS INTEGER) AS a1, a2], where=[(a1 = 2)])
+   :              +- TableSourceScan(table=[[default_catalog, default_database, A]], fields=[a1, a2, a3])
+   +- Exchange(distribution=[hash[b2]])
+      +- Calc(select=[b2])
+         +- GroupAggregate(groupBy=[b1], select=[b1, COUNT(b2) AS b2])
+            +- Exchange(distribution=[hash[b1]])
+               +- Calc(select=[CAST(2 AS INTEGER) AS b1, b2], where=[(b1 = 2)])
+                  +- TableSourceScan(table=[[default_catalog, default_database, B]], fields=[b1, b2, b3])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/BroadcastHashJoinTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/BroadcastHashJoinTest.scala
index ec3ada5a2fb6f..fd3bc8c2b1816 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/BroadcastHashJoinTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/BroadcastHashJoinTest.scala
@@ -124,4 +124,11 @@ class BroadcastHashJoinTest extends JoinTestBase {
       .hasMessageContaining("Cannot generate a valid execution plan for the given query")
       .isInstanceOf[TableException]
   }
+
+  @Test
+  override def testInnerJoinWithJoinConditionPushDown(): Unit = {
+    assertThatThrownBy(() => super.testInnerJoinWithJoinConditionPushDown())
+      .hasMessageContaining("Cannot generate a valid execution plan for the given query")
+      .isInstanceOf[TableException]
+  }
 }
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashJoinTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashJoinTest.scala
index e7ad20d02c49b..0370b2c4c0cc0 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashJoinTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/ShuffledHashJoinTest.scala
@@ -96,4 +96,11 @@ class ShuffledHashJoinTest extends JoinTestBase {
       .hasMessageContaining("Cannot generate a valid execution plan for the given query")
       .isInstanceOf[TableException]
   }
+
+  @Test
+  override def testInnerJoinWithJoinConditionPushDown(): Unit = {
+    assertThatThrownBy(() => super.testInnerJoinWithJoinConditionPushDown())
+      .hasMessageContaining("Cannot generate a valid execution plan for the given query")
+      .isInstanceOf[TableException]
+  }
 }
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.scala
index e10732166ee5e..dffbe8e8b8223 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.scala
@@ -94,4 +94,10 @@ class SortMergeJoinTest extends JoinTestBase {
       .isInstanceOf[TableException]
   }
 
+  @Test
+  override def testInnerJoinWithJoinConditionPushDown(): Unit = {
+    assertThatThrownBy(() => super.testInnerJoinWithJoinConditionPushDown())
+      .hasMessageContaining("Cannot generate a valid execution plan for the given query")
+      .isInstanceOf[TableException]
+  }
 }
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/runtime/batch/table/DecimalITCase.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/runtime/batch/table/DecimalITCase.scala
index d0e50a00da6ec..be8b8d791d042 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/runtime/batch/table/DecimalITCase.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/runtime/batch/table/DecimalITCase.scala
@@ -179,9 +179,6 @@ class DecimalITCase extends BatchTestBase {
 
   @Test
   def testJoin1(): Unit = {
-    tEnv.getConfig
-      .set(ExecutionConfigOptions.TABLE_EXEC_DISABLED_OPERATORS, "HashJoin, NestedLoopJoin")
-
     checkQuery(
       Seq(DECIMAL(8, 2), DECIMAL(8, 4), INT, DOUBLE),
       s1r(d"1", d"1", 1, 1.0),
@@ -193,9 +190,6 @@ class DecimalITCase extends BatchTestBase {
 
   @Test
   def testJoin2(): Unit = {
-    tEnv.getConfig
-      .set(ExecutionConfigOptions.TABLE_EXEC_DISABLED_OPERATORS, "HashJoin, NestedLoopJoin")
-
     checkQuery(
       Seq(DECIMAL(8, 2), DECIMAL(8, 4), INT, DOUBLE),
       s1r(d"1", d"1", 1, 1.0),
@@ -207,9 +201,6 @@ class DecimalITCase extends BatchTestBase {
 
   @Test
   def testJoin3(): Unit = {
-    tEnv.getConfig
-      .set(ExecutionConfigOptions.TABLE_EXEC_DISABLED_OPERATORS, "HashJoin, NestedLoopJoin")
-
     checkQuery(
       Seq(DECIMAL(8, 2), DECIMAL(8, 4), INT, DOUBLE),
       s1r(d"1", d"1", 1, 1.0),
@@ -222,9 +213,6 @@ class DecimalITCase extends BatchTestBase {
 
   @Test
   def testJoin4(): Unit = {
-    tEnv.getConfig
-      .set(ExecutionConfigOptions.TABLE_EXEC_DISABLED_OPERATORS, "HashJoin, NestedLoopJoin")
-
     checkQuery(
       Seq(DECIMAL(8, 2), DECIMAL(8, 4), INT, DOUBLE),
       s1r(d"1", d"1", 1, 1.0),
@@ -236,9 +224,6 @@ class DecimalITCase extends BatchTestBase {
 
   @Test
   def testJoin5(): Unit = {
-    tEnv.getConfig
-      .set(ExecutionConfigOptions.TABLE_EXEC_DISABLED_OPERATORS, "HashJoin, NestedLoopJoin")
-
     checkQuery(
       Seq(DECIMAL(8, 2), DECIMAL(8, 4), INT, DOUBLE),
       s1r(d"1", d"1", 1, 1.0),
@@ -250,9 +235,6 @@ class DecimalITCase extends BatchTestBase {
 
   @Test
   def testJoin6(): Unit = {
-    tEnv.getConfig
-      .set(ExecutionConfigOptions.TABLE_EXEC_DISABLED_OPERATORS, "HashJoin, NestedLoopJoin")
-
     checkQuery(
       Seq(DECIMAL(8, 2), DECIMAL(8, 4), INT, DOUBLE),
       s1r(d"1", d"1", 1, 1.0),
@@ -264,8 +246,6 @@ class DecimalITCase extends BatchTestBase {
 
   @Test
   def testJoin7(): Unit = {
-    tEnv.getConfig
-      .set(ExecutionConfigOptions.TABLE_EXEC_DISABLED_OPERATORS, "HashJoin, NestedLoopJoin")
     checkQuery(
       Seq(DECIMAL(8, 2), DECIMAL(8, 4), INT, DOUBLE),
       s1r(d"1", d"1", 1, 1.0),
diff --git a/flink-table/flink-table-runtime/src/main/resources/META-INF/NOTICE b/flink-table/flink-table-runtime/src/main/resources/META-INF/NOTICE
index 9889a10512ebc..0a2b4b723f1e9 100644
--- a/flink-table/flink-table-runtime/src/main/resources/META-INF/NOTICE
+++ b/flink-table/flink-table-runtime/src/main/resources/META-INF/NOTICE
@@ -7,5 +7,5 @@ The Apache Software Foundation (http://www.apache.org/).
 This project bundles the following dependencies under the Apache Software License 2.0. (http://www.apache.org/licenses/LICENSE-2.0.txt)
 
 - com.jayway.jsonpath:json-path:2.7.0
-- org.codehaus.janino:janino:3.1.11
-- org.codehaus.janino:commons-compiler:3.1.11
+- org.codehaus.janino:janino:3.1.12
+- org.codehaus.janino:commons-compiler:3.1.12
diff --git a/flink-table/pom.xml b/flink-table/pom.xml
index bf42e6ef5e4bf..c17c122c0e60a 100644
--- a/flink-table/pom.xml
+++ b/flink-table/pom.xml
@@ -79,8 +79,8 @@ under the License.
 	</dependencyManagement>
 
 	<properties>
-		<calcite.version>1.39.0</calcite.version>
-		<janino.version>3.1.11</janino.version>
+		<calcite.version>1.40.0</calcite.version>
+		<janino.version>3.1.12</janino.version>
 		<guava.version>33.4.0-jre</guava.version>
 		<quartz.version>2.5.2</quartz.version>
 	</properties>

From ee28e21d3cb74e52643dd7f07c7d7e0459929af2 Mon Sep 17 00:00:00 2001
From: Sergey Nuyanzin <snuyanzin@gmail.com>
Date: Wed, 3 Jun 2026 08:01:44 +0200
Subject: [PATCH 5/5] [FLINK-39859][table] Upgrade Calcite to 1.41.0

---
 flink-table/flink-sql-parser/pom.xml          |   13 +-
 .../src/main/codegen/data/Parser.tdd          |    1 +
 .../src/main/codegen/templates/Parser.jj      |   60 +-
 .../sql/SqlCollectionTypeNameSpec.java        |   20 +-
 .../calcite/sql/SqlMapTypeNameSpec.java       |    9 +-
 .../parser/validate/FlinkSqlConformance.java  |   10 +
 .../flink-table-calcite-bridge/pom.xml        |   10 +-
 flink-table/flink-table-planner/pom.xml       |   13 +
 .../calcite/rel/rules/SubQueryRemoveRule.java |  148 +-
 .../rel/type/RelDataTypeFactoryImpl.java      |   13 +-
 .../org/apache/calcite/rex/RexSimplify.java   | 3707 +++++++++++++++++
 .../java/org/apache/calcite/rex/RexUtil.java  |  134 +-
 .../apache/calcite/runtime/SqlFunctions.java  |  502 ++-
 .../calcite/sql/fun/SqlCoalesceFunction.java  |    9 +-
 .../calcite/sql/type/SqlTypeFactoryImpl.java  |    2 +
 .../apache/calcite/sql/type/SqlTypeUtil.java  |  217 +-
 .../sql/validate/SqlValidatorImpl.java        |  363 +-
 .../calcite/sql2rel/RelDecorrelator.java      |  327 +-
 .../calcite/sql2rel/SqlToRelConverter.java    |  236 +-
 .../nodes/exec/common/CommonExecMatch.java    |    8 +
 ...teToJoinFromTemporalTableFunctionRule.java |    6 +
 .../logical/RemoteCorrelateSplitRule.java     |    7 +
 ...SplitPythonConditionFromCorrelateRule.java |    7 +
 .../common/CommonPhysicalMatchRule.java       |    6 +
 .../table/planner/plan/utils/AsyncUtil.java   |    7 +
 .../plan/utils/ConstantFoldingUtil.java       |    7 +
 .../table/planner/plan/utils/PythonUtil.java  |   12 +
 .../src/main/resources/META-INF/NOTICE        |    8 +-
 .../planner/codegen/ExprCodeGenerator.scala   |    5 +
 .../rules/logical/RemoteCalcSplitRule.scala   |   11 +-
 .../table/planner/plan/utils/MatchUtil.scala  |    7 +-
 .../planner/plan/utils/RexNodeExtractor.scala |    5 +
 .../planner/plan/batch/sql/ValuesTest.xml     |    4 +-
 .../plan/batch/sql/agg/GroupingSetsTest.xml   |   22 +-
 .../batch/sql/join/BroadcastHashJoinTest.xml  |    2 +-
 .../batch/sql/join/NestedLoopJoinTest.xml     |    2 +-
 .../batch/sql/join/ShuffledHashJoinTest.xml   |    2 +-
 .../plan/batch/sql/join/SortMergeJoinTest.xml |    2 +-
 .../logical/DecomposeGroupingSetsRuleTest.xml |   13 +-
 .../rules/logical/FlinkFilterJoinRuleTest.xml |    4 +-
 .../logical/RemoveSingleAggregateRuleTest.xml |   18 +-
 .../SimplifyFilterConditionRuleTest.xml       |    4 +-
 .../logical/SimplifyJoinConditionRuleTest.xml |   20 +-
 .../logical/subquery/SubQueryAntiJoinTest.xml |   99 +-
 .../logical/subquery/SubQuerySemiJoinTest.xml |   42 +-
 .../plan/stream/sql/InsertIntoValuesTest.xml  |    4 +-
 .../planner/plan/stream/sql/ValuesTest.xml    |    4 +-
 .../plan/stream/sql/agg/GroupingSetsTest.xml  |   36 +
 .../FlinkRelMdDistinctRowCountTest.scala      |   19 +-
 .../FlinkRelMdPopulationSizeTest.scala        |    4 +-
 .../stream/sql/agg/GroupingSetsTest.scala     |    4 +-
 .../batch/sql/agg/GroupingSetsITCase.scala    |    7 +-
 flink-table/pom.xml                           |    2 +-
 53 files changed, 5757 insertions(+), 447 deletions(-)
 create mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexSimplify.java

diff --git a/flink-table/flink-sql-parser/pom.xml b/flink-table/flink-sql-parser/pom.xml
index 2c4c37d47bb67..9a682e56e0846 100644
--- a/flink-table/flink-sql-parser/pom.xml
+++ b/flink-table/flink-sql-parser/pom.xml
@@ -68,14 +68,15 @@ under the License.
 			<version>${calcite.version}</version>
 			<exclusions>
 				<!--
-				"mvn dependency:tree" as of Calcite 1.40.0:
+				"mvn dependency:tree" as of Calcite 1.41.0:
 
-				[INFO] +- org.apache.calcite:calcite-core:jar:1.40.0:compile
-				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.40.0:compile
-				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.26.0:compile
+				[INFO] +- org.apache.calcite:calcite-core:jar:1.41.0:compile
+				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.41.0:compile
+				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.27.0:compile
 				[INFO] |  +- org.apiguardian:apiguardian-api:jar:1.1.2:compile
-				[INFO] |  +- org.checkerframework:checker-qual:jar:3.43.0:compile
-				[INFO] |  \- org.apache.commons:commons-math3:jar:3.6.1:runtime
+				[INFO] |  +- org.checkerframework:checker-qual:jar:3.10.0:compile
+				[INFO] |  +- org.apache.commons:commons-math3:jar:3.6.1:runtime
+				[INFO] |  \- org.jooq:joou-java-6:jar:0.9.4:compile
 
 				Dependencies that are not needed for how we use Calcite right now.
 				-->
diff --git a/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd b/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd
index 84b69813a5247..b7e6d7ab9ea3f 100644
--- a/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd
+++ b/flink-table/flink-sql-parser/src/main/codegen/data/Parser.tdd
@@ -781,4 +781,5 @@
   includeBraces: true
   includeAdditionalDeclarations: false
   includeParsingStringLiteralAsArrayLiteral: false
+  includeIntervalWithoutQualifier: false
 }
diff --git a/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj b/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
index 3b03088e25ec1..38b6748352831 100644
--- a/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
+++ b/flink-table/flink-sql-parser/src/main/codegen/templates/Parser.jj
@@ -5232,6 +5232,19 @@ TimeUnit Second() :
     <SECONDS> { return warn(TimeUnit.SECOND); }
 }
 
+SqlIntervalQualifier IntervalWithoutQualifier() :
+{
+    final Span s;
+    int secondFracPrec = RelDataType.PRECISION_NOT_SPECIFIED;
+}
+{
+    {
+        s = span();
+        return new SqlIntervalQualifier(TimeUnit.SECOND, -1, null, secondFracPrec,
+            s.end(this));
+    }
+}
+
 SqlIntervalQualifier IntervalQualifier() :
 {
     final Span s;
@@ -5891,6 +5904,7 @@ SqlTypeNameSpec SqlTypeName(Span s) :
 SqlTypeNameSpec SqlTypeName1(Span s) :
 {
     final SqlTypeName sqlTypeName;
+    boolean unsigned = false;
 }
 {
     (
@@ -5904,13 +5918,40 @@ SqlTypeNameSpec SqlTypeName1(Span s) :
     |
         <BOOLEAN> { s.add(this); sqlTypeName = SqlTypeName.BOOLEAN; }
     |
-        ( <INTEGER> | <INT> ) { s.add(this); sqlTypeName = SqlTypeName.INTEGER; }
+        ( <INTEGER> | <INT> ) ( <UNSIGNED> { unsigned = true; })? {
+            if (unsigned && !this.conformance.supportsUnsignedTypes()) {
+                throw SqlUtil.newContextException(getPos(), RESOURCE.unsignedDisabled());
+            }
+            s.add(this); sqlTypeName = unsigned ? SqlTypeName.UINTEGER : SqlTypeName.INTEGER;
+        }
     |
-        <TINYINT> { s.add(this); sqlTypeName = SqlTypeName.TINYINT; }
+        <UNSIGNED> {
+            if (!this.conformance.supportsUnsignedTypes()) {
+                throw SqlUtil.newContextException(getPos(), RESOURCE.unsignedDisabled());
+            }
+            s.add(this); sqlTypeName = SqlTypeName.UINTEGER;
+        }
+    |
+        <TINYINT> ( <UNSIGNED> { unsigned = true; })? {
+            if (unsigned && !this.conformance.supportsUnsignedTypes()) {
+                throw SqlUtil.newContextException(getPos(), RESOURCE.unsignedDisabled());
+            }
+            s.add(this); sqlTypeName = unsigned ? SqlTypeName.UTINYINT : SqlTypeName.TINYINT;
+        }
     |
-        <SMALLINT> { s.add(this); sqlTypeName = SqlTypeName.SMALLINT; }
+        <SMALLINT> ( <UNSIGNED> { unsigned = true; })? {
+            if (unsigned && !this.conformance.supportsUnsignedTypes()) {
+                throw SqlUtil.newContextException(getPos(), RESOURCE.unsignedDisabled());
+            }
+            s.add(this); sqlTypeName = unsigned ? SqlTypeName.USMALLINT : SqlTypeName.SMALLINT;
+        }
     |
-        <BIGINT> { s.add(this); sqlTypeName = SqlTypeName.BIGINT; }
+        <BIGINT> ( <UNSIGNED> { unsigned = true; })? {
+            if (unsigned && !this.conformance.supportsUnsignedTypes()) {
+                throw SqlUtil.newContextException(getPos(), RESOURCE.unsignedDisabled());
+            }
+            s.add(this); sqlTypeName = unsigned ? SqlTypeName.UBIGINT : SqlTypeName.BIGINT;
+        }
     |
         <REAL> { s.add(this); sqlTypeName = SqlTypeName.REAL; }
     |
@@ -6296,7 +6337,12 @@ SqlNode BuiltinFunctionCall() :
         (
             dt = DataType() { args.add(dt); }
         |
+            LOOKAHEAD(2)
             <INTERVAL> e = IntervalQualifier() { args.add(e); }
+<#if (parser.includeIntervalWithoutQualifier!default.parser.includeIntervalWithoutQualifier) >
+        |
+            <INTERVAL> e = IntervalWithoutQualifier() { args.add(e); }
+</#if>
         )
         [ <FORMAT> format = StringLiteral() { args.add(format); } ]
         <RPAREN> {
@@ -7936,6 +7982,7 @@ SqlBinaryOperator BinaryRowOperator() :
 {
     // <IN> is handled as a special case
     <EQ> { return SqlStdOperatorTable.EQUALS; }
+|   <LEFTSHIFT> { return SqlStdOperatorTable.BIT_LEFT_SHIFT; }
 |   <GT> { return SqlStdOperatorTable.GREATER_THAN; }
 |   <LT> { return SqlStdOperatorTable.LESS_THAN; }
 |   <LE> { return SqlStdOperatorTable.LESS_THAN_OR_EQUAL; }
@@ -7967,7 +8014,9 @@ SqlBinaryOperator BinaryRowOperator() :
 |   <NOT> <SUBMULTISET> <OF> { return SqlStdOperatorTable.NOT_SUBMULTISET_OF; }
 |   <CONTAINS> { return SqlStdOperatorTable.CONTAINS; }
 |   <OVERLAPS> { return SqlStdOperatorTable.OVERLAPS; }
+|   <CARET> { return SqlStdOperatorTable.BITXOR_OPERATOR; }
 |   <EQUALS> { return SqlStdOperatorTable.PERIOD_EQUALS; }
+|   <AMPERSAND> { return SqlStdOperatorTable.BITAND_OPERATOR; }
 |   <PRECEDES> { return SqlStdOperatorTable.PRECEDES; }
 |   <SUCCEEDS> { return SqlStdOperatorTable.SUCCEEDS; }
 |   LOOKAHEAD(2) <IMMEDIATELY> <PRECEDES> { return SqlStdOperatorTable.IMMEDIATELY_PRECEDES; }
@@ -8714,6 +8763,7 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < UNPIVOT: "UNPIVOT" >
 |   < UNNAMED: "UNNAMED" >
 |   < UNNEST: "UNNEST" >
+|   < UNSIGNED: "UNSIGNED" >
 |   < UPDATE: "UPDATE" > { beforeTableName(); }
 |   < UPPER: "UPPER" >
 |   < UPSERT: "UPSERT" >
@@ -8957,6 +9007,8 @@ void NonReservedKeyWord2of3() :
 |   < DOUBLE_QUOTE: "\"" >
 |   < VERTICAL_BAR: "|" >
 |   < CARET: "^" >
+|   < AMPERSAND: "&" >
+|   < LEFTSHIFT: "<<" >
 |   < DOLLAR: "$" >
 <#list (parser.binaryOperatorsTokens!default.parser.binaryOperatorsTokens) as operator>
 |   ${operator}
diff --git a/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlCollectionTypeNameSpec.java b/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlCollectionTypeNameSpec.java
index a260a6a730d81..3ca5081b410b1 100644
--- a/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlCollectionTypeNameSpec.java
+++ b/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlCollectionTypeNameSpec.java
@@ -63,22 +63,40 @@
  */
 public class SqlCollectionTypeNameSpec extends SqlTypeNameSpec {
     private final SqlTypeNameSpec elementTypeName;
+    private final boolean elementTypeNullable;
     private final SqlTypeName collectionTypeName;
 
     /**
      * Creates a {@code SqlCollectionTypeNameSpec}.
      *
      * @param elementTypeName Type of the collection element
+     * @param elementTypeNullable Type of the collection element is nullable
      * @param collectionTypeName Collection type name
      * @param pos Parser position, must not be null
      */
     public SqlCollectionTypeNameSpec(
-            SqlTypeNameSpec elementTypeName, SqlTypeName collectionTypeName, SqlParserPos pos) {
+            SqlTypeNameSpec elementTypeName,
+            boolean elementTypeNullable,
+            SqlTypeName collectionTypeName,
+            SqlParserPos pos) {
         super(new SqlIdentifier(collectionTypeName.name(), pos), pos);
         this.elementTypeName = requireNonNull(elementTypeName, "elementTypeName");
+        this.elementTypeNullable = elementTypeNullable;
         this.collectionTypeName = requireNonNull(collectionTypeName, "collectionTypeName");
     }
 
+    /**
+     * Creates a {@code SqlCollectionTypeNameSpec}.
+     *
+     * @param elementTypeName Type of the collection element
+     * @param collectionTypeName Collection type name
+     * @param pos Parser position, must not be null
+     */
+    public SqlCollectionTypeNameSpec(
+            SqlTypeNameSpec elementTypeName, SqlTypeName collectionTypeName, SqlParserPos pos) {
+        this(elementTypeName, true, collectionTypeName, pos);
+    }
+
     public SqlTypeNameSpec getElementTypeName() {
         return elementTypeName;
     }
diff --git a/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlMapTypeNameSpec.java b/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlMapTypeNameSpec.java
index 827302de6a2a2..616dff23490f7 100644
--- a/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlMapTypeNameSpec.java
+++ b/flink-table/flink-sql-parser/src/main/java/org/apache/calcite/sql/SqlMapTypeNameSpec.java
@@ -57,9 +57,12 @@ public SqlDataTypeSpec getValType() {
 
     @Override
     public RelDataType deriveType(SqlValidator validator) {
-        return validator
-                .getTypeFactory()
-                .createMapType(keyType.deriveType(validator), valType.deriveType(validator));
+        boolean keyCanBeNullable =
+                validator.getTypeFactory().getTypeSystem().mapKeysCanBeNullable();
+        RelDataType kType = keyType.deriveType(validator, keyCanBeNullable);
+
+        RelDataType valueType = valType.deriveType(validator, true);
+        return validator.getTypeFactory().createMapType(kType, valueType);
     }
 
     @Override
diff --git a/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java b/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
index 0524581f2a39e..ccc1ef14f605a 100644
--- a/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
+++ b/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/validate/FlinkSqlConformance.java
@@ -47,6 +47,11 @@ public SelectAliasLookup isSelectAlias() {
         return SqlConformanceEnum.DEFAULT.isSelectAlias();
     }
 
+    @Override
+    public boolean isNonStrictGroupBy() {
+        return false;
+    }
+
     @Override
     public boolean isGroupByOrdinal() {
         return false;
@@ -192,6 +197,11 @@ public boolean checkedArithmetic() {
         return SqlConformanceEnum.DEFAULT.checkedArithmetic();
     }
 
+    @Override
+    public boolean supportsUnsignedTypes() {
+        return false;
+    }
+
     @Override
     public boolean isValueAllowed() {
         return true;
diff --git a/flink-table/flink-table-calcite-bridge/pom.xml b/flink-table/flink-table-calcite-bridge/pom.xml
index 90ade1deb93c9..77ee0a2fd4950 100644
--- a/flink-table/flink-table-calcite-bridge/pom.xml
+++ b/flink-table/flink-table-calcite-bridge/pom.xml
@@ -45,18 +45,18 @@ under the License.
 			<version>${calcite.version}</version>
 			<exclusions>
 				<!--
-				"mvn dependency:tree" as of Calcite 1.40.0:
-				[INFO] org.apache.flink:flink-table-calcite-bridge:jar:2.4-SNAPSHOT
-				[INFO] +- org.apache.calcite:calcite-core:jar:1.40.0:compile
-				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.40.0:compile
+				"mvn dependency:tree" as of Calcite 1.41.0:
+				[INFO] +- org.apache.calcite:calcite-core:jar:1.41.0:compile
+				[INFO] |  +- org.apache.calcite:calcite-linq4j:jar:1.41.0:compile
 				[INFO] |  +- org.locationtech.jts:jts-core:jar:1.19.0:compile
 				[INFO] |  +- com.fasterxml.jackson.core:jackson-annotations:jar:2.21:compile
-				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.26.0:compile
+				[INFO] |  +- org.apache.calcite.avatica:avatica-core:jar:1.27.0:compile
 				[INFO] |  +- org.apiguardian:apiguardian-api:jar:1.1.2:compile
 				[INFO] |  +- com.fasterxml.jackson.core:jackson-core:jar:2.21.3:compile
 				[INFO] |  +- com.fasterxml.jackson.core:jackson-databind:jar:2.21.3:compile
 				[INFO] |  +- commons-codec:commons-codec:jar:1.15:runtime
 				[INFO] |  +- org.apache.commons:commons-math3:jar:3.6.1:runtime
+				[INFO] |  +- org.jooq:joou-java-6:jar:0.9.4:compile
 				[INFO] |  \- commons-io:commons-io:jar:2.15.1:runtime
 				[INFO] +- com.jayway.jsonpath:json-path:jar:2.9.0:compile
 				[INFO] |  \- net.minidev:json-smart:jar:2.5.0:runtime
diff --git a/flink-table/flink-table-planner/pom.xml b/flink-table/flink-table-planner/pom.xml
index e37ffce9569bf..b8f76f7f96992 100644
--- a/flink-table/flink-table-planner/pom.xml
+++ b/flink-table/flink-table-planner/pom.xml
@@ -144,6 +144,12 @@ under the License.
 			<version>3.12.0</version>
 			<optional>${flink.markBundledAsOptional}</optional>
 		</dependency>
+		<dependency>
+			<groupId>org.jooq</groupId>
+			<artifactId>joou-java-6</artifactId>
+			<version>0.9.4</version>
+			<optional>${flink.markBundledAsOptional}</optional>
+		</dependency>
 
 		<!-- Table Runtime (not included in the uber) -->
 
@@ -371,6 +377,7 @@ under the License.
 							<include>commons-io:commons-io</include>
 							<include>org.apache.commons:commons-math3</include>
 							<include>org.checkerframework:checker-qual</include>
+							<include>org.jooq:joou-java-6</include>
 
 							<!-- flink-table-planner dependencies -->
 							<include>org.apache.flink:flink-sql-parser</include>
@@ -425,6 +432,12 @@ under the License.
 							<pattern>com.ibm.icu</pattern>
 							<shadedPattern>org.apache.flink.table.shaded.com.ibm.icu</shadedPattern>
 						</relocation>
+
+						<relocation>
+							<!-- org.jooq's dependencies, required for unsigned types -->
+							<pattern>org.jooq</pattern>
+							<shadedPattern>org.apache.flink.table.shaded.org.jooq</shadedPattern>
+						</relocation>
 					</relocations>
 				</configuration>
 			</plugin>
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
index 0114ad194fd27..3a78b222602f9 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
@@ -17,9 +17,11 @@
 package org.apache.calcite.rel.rules;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
 import org.apache.calcite.plan.RelOptRuleCall;
 import org.apache.calcite.plan.RelOptUtil;
 import org.apache.calcite.plan.RelRule;
+import org.apache.calcite.rel.RelHomogeneousShuttle;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.core.Collect;
 import org.apache.calcite.rel.core.CorrelationId;
@@ -30,6 +32,7 @@
 import org.apache.calcite.rel.metadata.RelMdUtil;
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.rex.LogicVisitor;
+import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
@@ -742,10 +745,29 @@ private static RexNode rewriteIn(
                 case TRUE_FALSE_UNKNOWN:
                 case UNKNOWN_AS_TRUE:
                     // Builds the cross join
-                    builder.aggregate(
-                            builder.groupKey(),
-                            builder.count(false, "c"),
-                            builder.count(builder.fields()).as("ck"));
+                    // Some databases don't support use FILTER clauses for aggregate functions
+                    // like {@code COUNT(*) FILTER (WHERE not(a is null))}
+                    // So use count(*) when only one column
+                    if (builder.fields().size() <= 1) {
+                        builder.aggregate(
+                                builder.groupKey(),
+                                builder.count(false, "c"),
+                                builder.count(builder.fields()).as("ck"));
+                    } else {
+                        builder.aggregate(
+                                builder.groupKey(),
+                                builder.count(false, "c"),
+                                builder.count()
+                                        .filter(
+                                                builder.not(
+                                                        builder.and(
+                                                                builder.fields().stream()
+                                                                        .map(builder::isNull)
+                                                                        .collect(
+                                                                                Collectors
+                                                                                        .toList()))))
+                                        .as("ck"));
+                    }
                     builder.as(ctAlias);
                     if (!variablesSet.isEmpty()) {
                         builder.join(JoinRelType.LEFT, trueLiteral, variablesSet);
@@ -925,13 +947,30 @@ private static void matchJoin(SubQueryRemoveRule rule, RelOptRuleCall call) {
         final Join join = call.rel(0);
         final RelBuilder builder = call.builder();
         final RexSubQuery e = requireNonNull(RexUtil.SubQueryFinder.find(join.getCondition()));
-        final RelOptUtil.Logic logic =
-                LogicVisitor.find(RelOptUtil.Logic.TRUE, ImmutableList.of(join.getCondition()), e);
 
         ImmutableBitSet inputSet = RelOptUtil.InputFinder.bits(e.getOperands(), null);
         int nFieldsLeft = join.getLeft().getRowType().getFieldCount();
         int nFieldsRight = join.getRight().getRowType().getFieldCount();
 
+        // Correlation columns should also be considered.
+        // For example:
+        //                                   LogicalJoin
+        //              left                                          right
+        //                |                                             |
+        // LogicalProject.NONE.[0, 1]                            LogicalValues.NONE.[0]
+        // RecordType(INTEGER DEPTNO, CHAR(11) DNAME)            RecordType(INTEGER DEPTNO)
+        //
+        // and subquery: $SCALAR_QUERY with correlate
+        // LogicalProject(DEPTNO=[$1])
+        //   LogicalFilter(condition=[=(CAST($0):CHAR(11) NOT NULL, $cor0.DNAME)])
+        //
+        // In such a case $cor0.DNAME need to be accounted as input form left side.
+        final Set<CorrelationId> variablesSet = RelOptUtil.getVariablesUsed(e.rel);
+        for (CorrelationId id : variablesSet) {
+            ImmutableBitSet requiredColumns = RelOptUtil.correlationColumns(id, e.rel);
+            inputSet = ImmutableBitSet.union(ImmutableList.of(requiredColumns, inputSet));
+        }
+
         boolean inputIntersectsLeftSide =
                 inputSet.intersects(ImmutableBitSet.range(0, nFieldsLeft));
         boolean inputIntersectsRightSide =
@@ -945,10 +984,17 @@ private static void matchJoin(SubQueryRemoveRule rule, RelOptRuleCall call) {
             return;
         }
 
-        final Set<CorrelationId> variablesSet = RelOptUtil.getVariablesUsed(e.rel);
         if (inputIntersectsLeftSide) {
             builder.push(join.getLeft());
 
+            final RelOptUtil.Logic logic =
+                    LogicVisitor.find(
+                            join.getJoinType().generatesNullsOnRight()
+                                    ? RelOptUtil.Logic.TRUE_FALSE_UNKNOWN
+                                    : RelOptUtil.Logic.TRUE,
+                            ImmutableList.of(join.getCondition()),
+                            e);
+
             final RexNode target = rule.apply(e, variablesSet, logic, builder, 1, nFieldsLeft, 0);
             final RexShuttle shuttle = new ReplaceSubQueryShuttle(e, target);
 
@@ -968,12 +1014,94 @@ private static void matchJoin(SubQueryRemoveRule rule, RelOptRuleCall call) {
                                     .union(ImmutableBitSet.range(nFields - nFieldsRight, nFields)));
             builder.project(fields);
         } else {
-            builder.push(join.getLeft());
             builder.push(join.getRight());
 
+            final RelOptUtil.Logic logic =
+                    LogicVisitor.find(
+                            join.getJoinType().generatesNullsOnLeft()
+                                    ? RelOptUtil.Logic.TRUE_FALSE_UNKNOWN
+                                    : RelOptUtil.Logic.TRUE,
+                            ImmutableList.of(join.getCondition()),
+                            e);
+
+            RexSubQuery subQuery = e;
+
+            if (!variablesSet.isEmpty()) {
+                // Original correlates reference joint row type, but we are about to create
+                // new join of original right side and correlated sub-query. Therefore we have
+                // to adjust correlated variables in following way:
+                //   1) new correlation variable must reference row type of right side only
+                //   2) field index must be shifted on the size of the left side
+                // Example:
+                // SELECT e1.*
+                // FROM emp e1
+                // JOIN dept d
+                //   ON e1.deptno = d.deptno
+                //   AND d.deptno IN (
+                //     SELECT e3.empno
+                //     FROM emp e3
+                //     WHERE d.deptno > e3.comm
+                //   )
+                // ORDER BY e1.empno, e1.deptno;
+                //
+                // LogicalJoin(condition=[AND(=($7, $8), IN(CAST($8):SMALLINT NOT NULL, {
+                // LogicalProject(EMPNO=[$0])
+                //   LogicalFilter(condition=[>(CAST($cor0.DEPTNO0):DECIMAL(7, 2) NOT NULL, $6)])
+                //     LogicalTableScan(table=[[scott, EMP]])
+                // }))], joinType=[inner])
+                //   LogicalTableScan(table=[[scott, EMP]])
+                //   LogicalProject(DEPTNO=[$0])
+                //     LogicalTableScan(table=[[scott, DEPT]])
+                //
+                // Rewrite to:
+                //
+                // LogicalProject(EMPNO=[$0], ENAME=[$1], ..., COMM=[$6], DEPTNO=[$7], DEPTNO0=[$8])
+                //   LogicalJoin(condition=[=($7, $8)], joinType=[inner])
+                //     LogicalTableScan(table=[[scott, EMP]])
+                //     LogicalFilter(condition=[=(CAST($0):SMALLINT NOT NULL, $1)])
+                //       LogicalCorrelate(correlation=[$cor0], joinType=[inner],
+                // requiredColumns=[{0}])
+                //         LogicalProject(DEPTNO=[$0])
+                //           LogicalTableScan(table=[[scott, DEPT]])
+                //         LogicalProject(EMPNO=[$0])
+                //           LogicalFilter(condition=[>(CAST($cor0.DEPTNO):DECIMAL(7, 2) NOT NULL,
+                // $6)])
+                //             LogicalTableScan(table=[[scott, EMP]])
+                CorrelationId id = Iterables.getOnlyElement(variablesSet);
+                RexBuilder rexBuilder = builder.getRexBuilder();
+
+                RelNode newSubQueryRel =
+                        e.rel.accept(
+                                new RelHomogeneousShuttle() {
+                                    @Override
+                                    public RelNode visit(RelNode other) {
+                                        RelNode node =
+                                                RexUtil.shiftFieldAccess(
+                                                        rexBuilder,
+                                                        other,
+                                                        id,
+                                                        join.getRight(),
+                                                        -nFieldsLeft);
+                                        return super.visit(node);
+                                    }
+                                });
+                subQuery = e.clone(newSubQueryRel);
+            }
+
+            subQuery =
+                    subQuery.clone(
+                            subQuery.getType(),
+                            RexUtil.shift(subQuery.getOperands(), -nFieldsLeft));
+
             final int nFields = join.getRowType().getFieldCount();
-            final RexNode target = rule.apply(e, variablesSet, logic, builder, 2, nFields, 0);
-            final RexShuttle shuttle = new ReplaceSubQueryShuttle(e, target);
+            final RexNode target =
+                    rule.apply(subQuery, variablesSet, logic, builder, 1, nFieldsRight, 0);
+            final RexShuttle shuttle =
+                    new ReplaceSubQueryShuttle(e, RexUtil.shift(target, nFieldsLeft));
+
+            RelNode newRight = builder.build();
+            builder.push(join.getLeft());
+            builder.push(newRight);
 
             builder.join(join.getJoinType(), shuttle.apply(join.getCondition()));
             builder.project(fields(builder, nFields));
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
index 9752813928f78..3ba7ea582554a 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
@@ -58,7 +58,6 @@
  * <p>FLINK modifications are at lines
  *
  * <ol>
- *   <li>Should be removed after fixing CALCITE-5199: Lines 242-244
  *   <li>Added in FLINK-39695 (backport of CALCITE-6764): Lines 407 ~ 438
  * </ol>
  */
@@ -238,9 +237,7 @@ private RelDataType createStructType(
 
         // recursively compute column-wise least restrictive
         // preserve the struct kind from type0
-        // FLINK MODIFICATION BEGIN
         final Builder builder = builder().kind(type0.getStructKind());
-        // FLINK MODIFICATION END
         for (int j = 0; j < fieldCount; ++j) {
             // REVIEW jvs 22-Jan-2004:  Always use the field name from the
             // first type?
@@ -277,9 +274,11 @@ private RelDataType createStructType(
         if (type == null) {
             return null;
         }
-        return sqlTypeName == SqlTypeName.ARRAY
-                ? new ArraySqlType(type, isNullable)
-                : new MultisetSqlType(type, isNullable);
+        RelDataType collection =
+                sqlTypeName == SqlTypeName.ARRAY
+                        ? createArrayType(type, -1)
+                        : createMultisetType(type, -1);
+        return createTypeWithNullability(collection, isNullable);
     }
 
     protected @Nullable RelDataType leastRestrictiveMapType(
@@ -302,7 +301,7 @@ private RelDataType createStructType(
         if (valueType == null) {
             return null;
         }
-        return new MapSqlType(keyType, valueType, isNullable);
+        return createTypeWithNullability(createMapType(keyType, valueType), isNullable);
     }
 
     protected RelDataType leastRestrictiveIntervalDatetimeType(
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexSimplify.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexSimplify.java
new file mode 100644
index 0000000000000..3f0f5539f8cc6
--- /dev/null
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexSimplify.java
@@ -0,0 +1,3707 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.rex;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.BoundType;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableRangeSet;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Range;
+import com.google.common.collect.RangeSet;
+import com.google.common.collect.Sets;
+import com.google.common.collect.TreeRangeSet;
+import org.apache.calcite.avatica.util.TimeUnit;
+import org.apache.calcite.avatica.util.TimeUnitRange;
+import org.apache.calcite.plan.RelOptPredicateList;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.plan.Strong;
+import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.metadata.NullSentinel;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.type.SqlTypeCoercionRule;
+import org.apache.calcite.sql.type.SqlTypeFamily;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.type.SqlTypeUtil;
+import org.apache.calcite.util.Bug;
+import org.apache.calcite.util.ImmutableBitSet;
+import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.RangeSets;
+import org.apache.calcite.util.Sarg;
+import org.apache.calcite.util.Util;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static java.util.Objects.requireNonNull;
+import static org.apache.calcite.linq4j.Nullness.castNonNull;
+import static org.apache.calcite.rex.RexUnknownAs.FALSE;
+import static org.apache.calcite.rex.RexUnknownAs.TRUE;
+import static org.apache.calcite.rex.RexUnknownAs.UNKNOWN;
+
+/** Context required to simplify a row-expression. */
+public class RexSimplify {
+    private final boolean paranoid;
+    public final RexBuilder rexBuilder;
+    private final RelOptPredicateList predicates;
+
+    /**
+     * How to treat UNKNOWN values, if one of the deprecated {@code simplify} methods without an
+     * {@code unknownAs} argument is called.
+     */
+    final RexUnknownAs defaultUnknownAs;
+
+    final boolean predicateElimination;
+    private final RexExecutor executor;
+
+    private static final Strong STRONG = new Strong();
+
+    /**
+     * Creates a RexSimplify.
+     *
+     * @param rexBuilder Rex builder
+     * @param predicates Predicates known to hold on input fields
+     * @param executor Executor for constant reduction, not null
+     */
+    public RexSimplify(
+            RexBuilder rexBuilder, RelOptPredicateList predicates, RexExecutor executor) {
+        this(rexBuilder, predicates, UNKNOWN, true, false, executor);
+    }
+
+    /** Internal constructor. */
+    private RexSimplify(
+            RexBuilder rexBuilder,
+            RelOptPredicateList predicates,
+            RexUnknownAs defaultUnknownAs,
+            boolean predicateElimination,
+            boolean paranoid,
+            RexExecutor executor) {
+        this.rexBuilder = requireNonNull(rexBuilder, "rexBuilder");
+        this.predicates = requireNonNull(predicates, "predicates");
+        this.defaultUnknownAs = requireNonNull(defaultUnknownAs, "defaultUnknownAs");
+        this.predicateElimination = predicateElimination;
+        this.paranoid = paranoid;
+        this.executor = requireNonNull(executor, "executor");
+    }
+
+    @Deprecated // to be removed before 2.0
+    public RexSimplify(RexBuilder rexBuilder, boolean unknownAsFalse, RexExecutor executor) {
+        this(
+                rexBuilder,
+                RelOptPredicateList.EMPTY,
+                RexUnknownAs.falseIf(unknownAsFalse),
+                true,
+                false,
+                executor);
+    }
+
+    @Deprecated // to be removed before 2.0
+    public RexSimplify(
+            RexBuilder rexBuilder,
+            RelOptPredicateList predicates,
+            boolean unknownAsFalse,
+            RexExecutor executor) {
+        this(rexBuilder, predicates, RexUnknownAs.falseIf(unknownAsFalse), true, false, executor);
+    }
+
+    // ~ Methods ----------------------------------------------------------------
+
+    /**
+     * Returns a RexSimplify the same as this but with a specified {@link #defaultUnknownAs} value.
+     *
+     * @deprecated Use methods with a {@link RexUnknownAs} argument, such as {@link
+     *     #simplify(RexNode, RexUnknownAs)}.
+     */
+    @Deprecated // to be removed before 2.0
+    public RexSimplify withUnknownAsFalse(boolean unknownAsFalse) {
+        final RexUnknownAs defaultUnknownAs = RexUnknownAs.falseIf(unknownAsFalse);
+        return defaultUnknownAs == this.defaultUnknownAs
+                ? this
+                : new RexSimplify(
+                        rexBuilder,
+                        predicates,
+                        defaultUnknownAs,
+                        predicateElimination,
+                        paranoid,
+                        executor);
+    }
+
+    /** Returns a RexSimplify the same as this but with a specified {@link #predicates} value. */
+    public RexSimplify withPredicates(RelOptPredicateList predicates) {
+        return predicates == this.predicates
+                ? this
+                : new RexSimplify(
+                        rexBuilder,
+                        predicates,
+                        defaultUnknownAs,
+                        predicateElimination,
+                        paranoid,
+                        executor);
+    }
+
+    /**
+     * Returns a RexSimplify the same as this but which verifies that the expression before and
+     * after simplification are equivalent.
+     *
+     * @see #verify
+     */
+    public RexSimplify withParanoid(boolean paranoid) {
+        return paranoid == this.paranoid
+                ? this
+                : new RexSimplify(
+                        rexBuilder,
+                        predicates,
+                        defaultUnknownAs,
+                        predicateElimination,
+                        paranoid,
+                        executor);
+    }
+
+    /**
+     * Returns a RexSimplify the same as this but with a specified {@link #predicateElimination}
+     * value.
+     *
+     * <p>This is introduced temporarily, until {@link Bug#CALCITE_2401_FIXED [CALCITE-2401] is
+     * fixed}.
+     */
+    private RexSimplify withPredicateElimination(boolean predicateElimination) {
+        return predicateElimination == this.predicateElimination
+                ? this
+                : new RexSimplify(
+                        rexBuilder,
+                        predicates,
+                        defaultUnknownAs,
+                        predicateElimination,
+                        paranoid,
+                        executor);
+    }
+
+    /**
+     * Simplifies a boolean expression, always preserving its type and its nullability.
+     *
+     * <p>This is useful if you are simplifying expressions in a {@link Project}.
+     */
+    public RexNode simplifyPreservingType(RexNode e) {
+        return simplifyPreservingType(e, defaultUnknownAs, true);
+    }
+
+    public RexNode simplifyPreservingType(
+            RexNode e, RexUnknownAs unknownAs, boolean matchNullability) {
+        final RexNode e2 = simplifyUnknownAs(e, unknownAs);
+        if (e2.getType() == e.getType()) {
+            return e2;
+        }
+        if (!matchNullability
+                && SqlTypeUtil.equalSansNullability(
+                        rexBuilder.typeFactory, e2.getType(), e.getType())) {
+            return e2;
+        }
+        final RexNode e3 = rexBuilder.makeCast(e.getType(), e2, matchNullability, false);
+        if (e3.equals(e)) {
+            return e;
+        }
+        return e3;
+    }
+
+    /**
+     * Simplifies a boolean expression.
+     *
+     * <p>In particular:
+     *
+     * <ul>
+     *   <li>{@code simplify(x = 1 OR NOT x = 1 OR x IS NULL)} returns {@code TRUE}
+     *   <li>{@code simplify(x = 1 AND FALSE)} returns {@code FALSE}
+     * </ul>
+     *
+     * <p>Handles UNKNOWN values using the policy specified when you created this {@code
+     * RexSimplify}. Unless you used a deprecated constructor, that policy is {@link
+     * RexUnknownAs#UNKNOWN}.
+     *
+     * <p>If the expression is a predicate in a WHERE clause, consider instead using {@link
+     * #simplifyUnknownAsFalse(RexNode)}.
+     *
+     * @param e Expression to simplify
+     */
+    public RexNode simplify(RexNode e) {
+        return simplifyUnknownAs(e, defaultUnknownAs);
+    }
+
+    /**
+     * As {@link #simplify(RexNode)}, but for a boolean expression for which a result of UNKNOWN
+     * will be treated as FALSE.
+     *
+     * <p>Use this form for expressions on a WHERE, ON, HAVING or FILTER(WHERE) clause.
+     *
+     * <p>This may allow certain additional simplifications. A result of UNKNOWN may yield FALSE,
+     * however it may still yield UNKNOWN. (If the simplified expression has type BOOLEAN NOT NULL,
+     * then of course it can only return FALSE.)
+     */
+    public final RexNode simplifyUnknownAsFalse(RexNode e) {
+        return simplifyUnknownAs(e, FALSE);
+    }
+
+    /**
+     * As {@link #simplify(RexNode)}, but specifying how UNKNOWN values are to be treated.
+     *
+     * <p>If UNKNOWN is treated as FALSE, this may allow certain additional simplifications. A
+     * result of UNKNOWN may yield FALSE, however it may still yield UNKNOWN. (If the simplified
+     * expression has type BOOLEAN NOT NULL, then of course it can only return FALSE.)
+     */
+    public RexNode simplifyUnknownAs(RexNode e, RexUnknownAs unknownAs) {
+        final RexNode simplified = withParanoid(false).simplify(e, unknownAs);
+        if (paranoid) {
+            verify(e, simplified, unknownAs);
+        }
+        return simplified;
+    }
+
+    /**
+     * Internal method to simplify an expression.
+     *
+     * <p>Unlike the public {@link #simplify(RexNode)} and {@link #simplifyUnknownAsFalse(RexNode)}
+     * methods, never calls {@link #verify(RexNode, RexNode, RexUnknownAs)}. Verify adds an overhead
+     * that is only acceptable for a top-level call.
+     */
+    RexNode simplify(RexNode e, RexUnknownAs unknownAs) {
+        if (isSafeExpression(e) && STRONG.isNull(e)) {
+            // Only boolean NULL (aka UNKNOWN) can be converted to FALSE. Even in
+            // unknownAs=FALSE mode, we must not convert a NULL integer (say) to FALSE
+            if (e.getType().getSqlTypeName() == SqlTypeName.BOOLEAN) {
+                switch (unknownAs) {
+                    case FALSE:
+                    case TRUE:
+                        return rexBuilder.makeLiteral(unknownAs.toBoolean());
+                    default:
+                        break;
+                }
+            }
+            return rexBuilder.makeNullLiteral(e.getType());
+        }
+        switch (e.getKind()) {
+            case AND:
+                return simplifyAnd((RexCall) e, unknownAs);
+            case OR:
+                return simplifyOr((RexCall) e, unknownAs);
+            case NOT:
+                return simplifyNot((RexCall) e, unknownAs);
+            case CASE:
+                return simplifyCase((RexCall) e, unknownAs);
+            case COALESCE:
+                return simplifyCoalesce((RexCall) e);
+            case CAST:
+            case SAFE_CAST:
+                return simplifyCast((RexCall) e);
+            case CEIL:
+            case FLOOR:
+                return simplifyCeilFloor((RexCall) e);
+            case TRIM:
+                return simplifyTrim((RexCall) e);
+            case IS_NULL:
+            case IS_NOT_NULL:
+            case IS_TRUE:
+            case IS_NOT_TRUE:
+            case IS_FALSE:
+            case IS_NOT_FALSE:
+                assert e instanceof RexCall;
+                return simplifyIs((RexCall) e, unknownAs);
+            case EQUALS:
+            case GREATER_THAN:
+            case GREATER_THAN_OR_EQUAL:
+            case LESS_THAN:
+            case LESS_THAN_OR_EQUAL:
+            case NOT_EQUALS:
+                return simplifyComparison((RexCall) e, unknownAs);
+            case SEARCH:
+                return simplifySearch((RexCall) e, unknownAs);
+            case LIKE:
+                return simplifyLike((RexCall) e, unknownAs);
+            case MINUS_PREFIX:
+            case CHECKED_MINUS_PREFIX:
+                return simplifyUnaryMinus((RexCall) e, unknownAs);
+            case PLUS_PREFIX:
+                return simplifyUnaryPlus((RexCall) e, unknownAs);
+            case PLUS:
+            case MINUS:
+            case TIMES:
+            case DIVIDE:
+            case CHECKED_PLUS:
+            case CHECKED_MINUS:
+            case CHECKED_TIMES:
+            case CHECKED_DIVIDE:
+                return simplifyArithmetic((RexCall) e);
+            case M2V:
+                return simplifyM2v((RexCall) e);
+            default:
+                if (e.getClass() == RexCall.class) {
+                    return simplifyGenericNode((RexCall) e);
+                } else {
+                    return e;
+                }
+        }
+    }
+
+    /** Applies NOT to an expression. */
+    RexNode not(RexNode e) {
+        return RexUtil.not(rexBuilder, e);
+    }
+
+    /** Applies IS NOT FALSE to an expression. */
+    RexNode isNotFalse(RexNode e) {
+        return e.isAlwaysTrue()
+                ? rexBuilder.makeLiteral(true)
+                : e.isAlwaysFalse()
+                        ? rexBuilder.makeLiteral(false)
+                        : e.getKind() == SqlKind.NOT
+                                ? isNotTrue(((RexCall) e).operands.get(0))
+                                : predicates.isEffectivelyNotNull(e)
+                                        ? e // would "CAST(e AS BOOLEAN NOT NULL)" better?
+                                        : rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_FALSE, e);
+    }
+
+    /** Applies IS NOT TRUE to an expression. */
+    RexNode isNotTrue(RexNode e) {
+        return e.isAlwaysTrue()
+                ? rexBuilder.makeLiteral(false)
+                : e.isAlwaysFalse()
+                        ? rexBuilder.makeLiteral(true)
+                        : e.getKind() == SqlKind.NOT
+                                ? isNotFalse(((RexCall) e).operands.get(0))
+                                : predicates.isEffectivelyNotNull(e)
+                                        ? not(e)
+                                        : rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_TRUE, e);
+    }
+
+    /** Applies IS TRUE to an expression. */
+    RexNode isTrue(RexNode e) {
+        return e.isAlwaysTrue()
+                ? rexBuilder.makeLiteral(true)
+                : e.isAlwaysFalse()
+                        ? rexBuilder.makeLiteral(false)
+                        : e.getKind() == SqlKind.NOT
+                                ? isFalse(((RexCall) e).operands.get(0))
+                                : predicates.isEffectivelyNotNull(e)
+                                        ? e // would "CAST(e AS BOOLEAN NOT NULL)" better?
+                                        : rexBuilder.makeCall(SqlStdOperatorTable.IS_TRUE, e);
+    }
+
+    /** Applies IS FALSE to an expression. */
+    RexNode isFalse(RexNode e) {
+        return e.isAlwaysTrue()
+                ? rexBuilder.makeLiteral(false)
+                : e.isAlwaysFalse()
+                        ? rexBuilder.makeLiteral(true)
+                        : e.getKind() == SqlKind.NOT
+                                ? isTrue(((RexCall) e).operands.get(0))
+                                : predicates.isEffectivelyNotNull(e)
+                                        ? not(e)
+                                        : rexBuilder.makeCall(SqlStdOperatorTable.IS_FALSE, e);
+    }
+
+    /** Runs simplification inside a non-specialized node. */
+    private RexNode simplifyGenericNode(RexCall e) {
+        final List<RexNode> operands = new ArrayList<>(e.operands);
+        simplifyList(operands, UNKNOWN);
+        if (e.operands.equals(operands)) {
+            return e;
+        }
+        return rexBuilder.makeCall(e.getParserPosition(), e.getType(), e.getOperator(), operands);
+    }
+
+    /**
+     * Try to find a literal with the given value in the input list. The type of the literal must be
+     * one of the numeric types.
+     */
+    private static int findLiteralIndex(List<RexNode> operands, BigDecimal value) {
+        for (int i = 0; i < operands.size(); i++) {
+            if (operands.get(i).isA(SqlKind.LITERAL)) {
+                Comparable comparable = ((RexLiteral) operands.get(i)).getValue();
+                if (comparable instanceof BigDecimal
+                        && value.compareTo((BigDecimal) comparable) == 0) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+
+    private RexNode simplifyArithmetic(RexCall e) {
+        if (e.getType().getSqlTypeName().getFamily() != SqlTypeFamily.NUMERIC
+                || e.getOperands().stream()
+                        .anyMatch(
+                                o ->
+                                        e.getType().getSqlTypeName().getFamily()
+                                                != SqlTypeFamily.NUMERIC)) {
+            // we only support simplifying numeric types.
+            return simplifyGenericNode(e);
+        }
+
+        assert e.getOperands().size() == 2;
+
+        switch (e.getKind()) {
+            // These simplifications are safe for both checked and unchecked arithemtic.
+            case PLUS:
+            case CHECKED_PLUS:
+                return simplifyPlus(e);
+            case MINUS:
+            case CHECKED_MINUS:
+                return simplifyMinus(e);
+            case TIMES:
+            case CHECKED_TIMES:
+                return simplifyMultiply(e);
+            case DIVIDE:
+            case CHECKED_DIVIDE:
+                return simplifyDivide(e);
+            default:
+                throw new IllegalArgumentException(
+                        "Unsupported arithmeitc operation " + e.getKind());
+        }
+    }
+
+    private RexNode simplifyPlus(RexCall e) {
+        final int zeroIndex = findLiteralIndex(e.operands, BigDecimal.ZERO);
+        if (zeroIndex >= 0) {
+            // return the other operand.
+            RexNode other = e.getOperands().get((zeroIndex + 1) % 2);
+            return other.getType().equals(e.getType())
+                    ? other
+                    : rexBuilder.makeCast(e.getParserPosition(), e.getType(), other);
+        }
+        return simplifyGenericNode(e);
+    }
+
+    private RexNode simplifyMinus(RexCall e) {
+        final int zeroIndex = findLiteralIndex(e.operands, BigDecimal.ZERO);
+        if (zeroIndex == 1) {
+            RexNode leftOperand = e.getOperands().get(0);
+            return leftOperand.getType().equals(e.getType())
+                    ? leftOperand
+                    : rexBuilder.makeCast(e.getParserPosition(), e.getType(), leftOperand);
+        }
+        return simplifyGenericNode(e);
+    }
+
+    private RexNode simplifyMultiply(RexCall e) {
+        final int oneIndex = findLiteralIndex(e.operands, BigDecimal.ONE);
+        if (oneIndex >= 0) {
+            // return the other operand.
+            RexNode other = e.getOperands().get((oneIndex + 1) % 2);
+            return other.getType().equals(e.getType())
+                    ? other
+                    : rexBuilder.makeCast(e.getParserPosition(), e.getType(), other);
+        }
+        return simplifyGenericNode(e);
+    }
+
+    private RexNode simplifyDivide(RexCall e) {
+        final int oneIndex = findLiteralIndex(e.operands, BigDecimal.ONE);
+        if (oneIndex == 1) {
+            RexNode leftOperand = e.getOperands().get(0);
+            return leftOperand.getType().equals(e.getType())
+                    ? leftOperand
+                    : rexBuilder.makeCast(e.getParserPosition(), e.getType(), leftOperand);
+        }
+        return simplifyGenericNode(e);
+    }
+
+    private RexNode simplifyLike(RexCall e, RexUnknownAs unknownAs) {
+        if (e.operands.get(1) instanceof RexLiteral) {
+            final RexLiteral literal = (RexLiteral) e.operands.get(1);
+            String likeStr = requireNonNull(literal.getValueAs(String.class));
+            Pattern pattern = Pattern.compile("%+");
+            String value = pattern.matcher(likeStr).replaceAll("%");
+            if ("%".equals(value)) {
+                // "x LIKE '%'" or "x LIKE '%...'" simplifies to "x = x"
+                final RexNode x = e.operands.get(0);
+                return simplify(
+                        rexBuilder.makeCall(
+                                e.getParserPosition(), SqlStdOperatorTable.EQUALS, x, x),
+                        unknownAs);
+            }
+            // simplify "x LIKE '%%\%%a%%%'" to "x LIKE '%\%%a%'", default escape is '\'
+            if (e.operands.size() == 2) {
+                e =
+                        (RexCall)
+                                rexBuilder.makeCall(
+                                        e.getParserPosition(),
+                                        e.getOperator(),
+                                        e.operands.get(0),
+                                        rexBuilder.makeLiteral(
+                                                simplifyLikeString(likeStr, '\\', '%')));
+            }
+            if (e.operands.size() == 3 && e.operands.get(2) instanceof RexLiteral) {
+                final RexLiteral escapeLiteral = (RexLiteral) e.operands.get(2);
+                // FLINK MODIFICATION BEGIN, CALCITE-7578
+                final String escapeStr = requireNonNull(escapeLiteral.getValueAs(String.class));
+                if (escapeStr.length() == 1) {
+                    char escape = escapeStr.charAt(0);
+                    e =
+                            (RexCall)
+                                    rexBuilder.makeCall(
+                                            e.getParserPosition(),
+                                            e.getOperator(),
+                                            e.operands.get(0),
+                                            rexBuilder.makeLiteral(
+                                                    simplifyLikeString(likeStr, escape, '%')),
+                                            escapeLiteral);
+                }
+                // FLINK MODIFICATION END
+            }
+        }
+        return simplifyGenericNode(e);
+    }
+
+    // string 'AA%%__%%AA' simplify to 'AA__%AA'
+    // string with even escapes 'AA\\\\%%__%%AA' simplify to 'AA\\__%AA'
+    // string with odd escapes 'AA\\\\\\%%__%%AA' simplify to 'AA\\\\\\%__%AA'
+    private String simplifyMixedWildcards(String str, char escape) {
+        // FLINK MODIFICATION BEGIN
+        Pattern pattern = getMixedWildCardPattern(escape);
+        // FLINK MODIFICATION END
+        Matcher matcher = pattern.matcher(str);
+        StringBuilder builder = new StringBuilder();
+        int from = 0;
+        while (matcher.find()) {
+            int start = matcher.start();
+            String group = requireNonNull(matcher.group(0));
+            if (start > 0
+                    && str.charAt(start - 1) == escape
+                    && consecutiveSameCharCountBefore(str, start - 1, escape) % 2 == 1) {
+                builder.append(str, from, start + 1);
+                builder.append(simplifyPercentAndUnderline(group.substring(1)));
+            } else {
+                builder.append(str, from, start);
+                builder.append(simplifyPercentAndUnderline(group));
+            }
+            from = matcher.end();
+        }
+        if (from < str.length()) {
+            builder.append(str.substring(from));
+        }
+        return builder.toString();
+    }
+
+    // FLINK MODIFICATION BEGIN
+    private static Pattern getMixedWildCardPattern(char escape) {
+        switch (escape) {
+            case '%':
+                return Pattern.compile("_+");
+            case '_':
+                return Pattern.compile("%+");
+            default:
+                return Pattern.compile("[_%]+");
+        }
+    }
+
+    // FLINK MODIFICATION END
+
+    // Tool method: count the number of consecutive identical characters before index
+    private int consecutiveSameCharCountBefore(String str, int index, char escape) {
+        int count = 0;
+        while (index >= 0) {
+            if (str.charAt(index) != escape) {
+                break;
+            }
+            count++;
+            index--;
+        }
+        return count;
+    }
+
+    // Tool method: simplified string mixed with '%' and '_'
+    private String simplifyPercentAndUnderline(String str) {
+        StringBuilder builder = new StringBuilder();
+        boolean containsPercent = false;
+        for (int index = 0; index < str.length(); index++) {
+            if (str.charAt(index) == '%') {
+                containsPercent = true;
+                continue;
+            }
+            if (str.charAt(index) == '_') {
+                builder.append('_');
+            }
+        }
+        if (containsPercent) {
+            builder.append('%');
+        }
+        return builder.toString();
+    }
+
+    /**
+     * Simplifies like string with escape. A like '%%#%%A%%' escape '#' should simplify to A like
+     * '%#%%A%' escape '#'.
+     */
+    private String simplifyLikeString(String content, char escape, char wildcard) {
+        int escapeCount = 0;
+        int wildcardCount = 0;
+        StringBuilder builder = new StringBuilder();
+        for (int index = 0; index < content.length(); index++) {
+            char c = content.charAt(index);
+            if (c == escape) {
+                builder.append(c);
+                escapeCount++;
+                wildcardCount = 0;
+                continue;
+            }
+            if (c == wildcard) {
+                if (escapeCount % 2 == 1) {
+                    builder.append(wildcard);
+                } else if (wildcardCount == 0) {
+                    builder.append(wildcard);
+                    wildcardCount++;
+                }
+                escapeCount = 0;
+                continue;
+            }
+            builder.append(c);
+            escapeCount = 0;
+            wildcardCount = 0;
+        }
+        return simplifyMixedWildcards(builder.toString(), escape);
+    }
+
+    // e must be a comparison (=, >, >=, <, <=, !=)
+    private RexNode simplifyComparison(RexCall e, RexUnknownAs unknownAs) {
+        //noinspection unchecked
+        return simplifyComparison(e, unknownAs, Comparable.class);
+    }
+
+    // e must be a comparison (=, >, >=, <, <=, !=)
+    private <C extends Comparable<C>> RexNode simplifyComparison(
+            RexCall e, RexUnknownAs unknownAs, Class<C> clazz) {
+        final List<RexNode> operands = new ArrayList<>(e.operands);
+        // UNKNOWN mode is warranted: false = null
+        simplifyList(operands, UNKNOWN);
+
+        // Simplify "x <op> x"
+        final RexNode o0 = operands.get(0);
+        final RexNode o1 = operands.get(1);
+        if (o0.equals(o1) && RexUtil.isDeterministic(o0)) {
+            RexNode newExpr;
+            switch (e.getKind()) {
+                case EQUALS:
+                case GREATER_THAN_OR_EQUAL:
+                case LESS_THAN_OR_EQUAL:
+                    // "x = x" simplifies to "null or x is not null" (similarly <= and >=)
+                    newExpr =
+                            rexBuilder.makeCall(
+                                    e.getParserPosition(),
+                                    SqlStdOperatorTable.OR,
+                                    rexBuilder.makeNullLiteral(e.getType()),
+                                    rexBuilder.makeCall(
+                                            e.getParserPosition(),
+                                            SqlStdOperatorTable.IS_NOT_NULL,
+                                            o0));
+                    return simplify(newExpr, unknownAs);
+                case NOT_EQUALS:
+                case LESS_THAN:
+                case GREATER_THAN:
+                    // "x != x" simplifies to "null and x is null" (similarly < and >)
+                    newExpr =
+                            rexBuilder.makeCall(
+                                    e.getParserPosition(),
+                                    SqlStdOperatorTable.AND,
+                                    rexBuilder.makeNullLiteral(e.getType()),
+                                    rexBuilder.makeCall(
+                                            e.getParserPosition(),
+                                            SqlStdOperatorTable.IS_NULL,
+                                            o0));
+                    return simplify(newExpr, unknownAs);
+                default:
+                    // unknown kind
+            }
+        }
+
+        if (o0.getType().getSqlTypeName() == SqlTypeName.BOOLEAN) {
+            Comparison cmp =
+                    Comparison.of(
+                            rexBuilder.makeCall(e.getParserPosition(), e.getOperator(), o0, o1),
+                            node -> true);
+            if (cmp != null) {
+                if (cmp.literal.isAlwaysTrue()) {
+                    switch (cmp.kind) {
+                        case GREATER_THAN_OR_EQUAL:
+                        case EQUALS: // x=true
+                            return cmp.ref;
+                        case LESS_THAN:
+                        case NOT_EQUALS: // x!=true
+                            return simplify(not(cmp.ref), unknownAs);
+                        case GREATER_THAN:
+                            /* this is false, but could be null if x is null */
+                            if (!cmp.ref.getType().isNullable()) {
+                                return rexBuilder.makeLiteral(false);
+                            }
+                            break;
+                        case LESS_THAN_OR_EQUAL:
+                            /* this is true, but could be null if x is null */
+                            if (!cmp.ref.getType().isNullable()) {
+                                return rexBuilder.makeLiteral(true);
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                if (cmp.literal.isAlwaysFalse()) {
+                    switch (cmp.kind) {
+                        case EQUALS:
+                        case LESS_THAN_OR_EQUAL:
+                            return simplify(not(cmp.ref), unknownAs);
+                        case NOT_EQUALS:
+                        case GREATER_THAN:
+                            return cmp.ref;
+                        case GREATER_THAN_OR_EQUAL:
+                            /* this is true, but could be null if x is null */
+                            if (!cmp.ref.getType().isNullable()) {
+                                return rexBuilder.makeLiteral(true);
+                            }
+                            break;
+                        case LESS_THAN:
+                            /* this is false, but could be null if x is null */
+                            if (!cmp.ref.getType().isNullable()) {
+                                return rexBuilder.makeLiteral(false);
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
+        }
+
+        // Simplify "<literal1> <op> <literal2>"
+        // For example, "1 = 2" becomes FALSE;
+        // "1 != 1" becomes FALSE;
+        // "1 != NULL" becomes UNKNOWN (or FALSE if unknownAsFalse);
+        // "1 != '1'" is unchanged because the types are not the same.
+        if (o0.isA(SqlKind.LITERAL)
+                && o1.isA(SqlKind.LITERAL)
+                && SqlTypeUtil.equalSansNullability(
+                        rexBuilder.getTypeFactory(), o0.getType(), o1.getType())) {
+            final C v0 = ((RexLiteral) o0).getValueAs(clazz);
+            final C v1 = ((RexLiteral) o1).getValueAs(clazz);
+            if (v0 == null || v1 == null) {
+                return unknownAs == FALSE
+                        ? rexBuilder.makeLiteral(false)
+                        : rexBuilder.makeNullLiteral(e.getType());
+            }
+            final int comparisonResult = v0.compareTo(v1);
+            switch (e.getKind()) {
+                case EQUALS:
+                    return rexBuilder.makeLiteral(comparisonResult == 0);
+                case GREATER_THAN:
+                    return rexBuilder.makeLiteral(comparisonResult > 0);
+                case GREATER_THAN_OR_EQUAL:
+                    return rexBuilder.makeLiteral(comparisonResult >= 0);
+                case LESS_THAN:
+                    return rexBuilder.makeLiteral(comparisonResult < 0);
+                case LESS_THAN_OR_EQUAL:
+                    return rexBuilder.makeLiteral(comparisonResult <= 0);
+                case NOT_EQUALS:
+                    return rexBuilder.makeLiteral(comparisonResult != 0);
+                default:
+                    throw new AssertionError();
+            }
+        }
+
+        RexNode node = simplifyComparisonWithNull(e, unknownAs);
+        if (node instanceof RexLiteral) {
+            return node;
+        }
+
+        // If none of the arguments were simplified, return the call unchanged.
+        final RexNode e2;
+        if (operands.equals(e.operands)) {
+            e2 = e;
+        } else {
+            e2 = rexBuilder.makeCall(e.getParserPosition(), e.op, operands);
+        }
+        return simplifyUsingPredicates(e2, clazz);
+    }
+
+    /**
+     * If this RexNode is a comparison against NULL, return FALSE, otherwise return it unchanged.
+     */
+    static RexNode simplifyComparisonWithNull(
+            RexNode e, RexBuilder rexBuilder, RexUnknownAs unknownAs) {
+        final RexSimplify.Comparison comparison = RexSimplify.Comparison.of(e);
+        if (comparison != null) {
+            boolean againstNull = comparison.literal.isNull();
+            // There is another possibility to check: in a comparison like 1 = null,
+            // the "non-literal" side of the Comparison can be null
+            if (comparison.ref instanceof RexLiteral) {
+                againstNull = againstNull || ((RexLiteral) comparison.ref).isNull();
+            }
+            if (againstNull) {
+                return unknownAs == FALSE
+                        ? rexBuilder.makeLiteral(false)
+                        : rexBuilder.makeNullLiteral(e.getType());
+            }
+        }
+        return e;
+    }
+
+    public static RexNode simplifyComparisonWithNull(RexNode e, RexBuilder rexBuilder) {
+        return RexSimplify.simplifyComparisonWithNull(e, rexBuilder, FALSE);
+    }
+
+    /**
+     * If this RexNode is a comparison against NULL, return a simplified form, otherwise return it
+     * unchanged.
+     */
+    public RexNode simplifyComparisonWithNull(RexNode e, RexUnknownAs unknownAs) {
+        return simplifyComparisonWithNull(e, this.rexBuilder, unknownAs);
+    }
+
+    /** Simplifies a conjunction of boolean expressions. */
+    @Deprecated // to be removed before 2.0
+    public RexNode simplifyAnds(Iterable<? extends RexNode> nodes) {
+        ensureParanoidOff();
+        return simplifyAnds(nodes, defaultUnknownAs);
+    }
+
+    // package-protected only for a deprecated method; treat as private
+    RexNode simplifyAnds(Iterable<? extends RexNode> nodes, RexUnknownAs unknownAs) {
+        final List<RexNode> terms = new ArrayList<>();
+        final List<RexNode> notTerms = new ArrayList<>();
+        for (RexNode e : nodes) {
+            RelOptUtil.decomposeConjunction(e, terms, notTerms);
+        }
+        simplifyList(terms, UNKNOWN);
+        simplifyList(notTerms, UNKNOWN);
+        if (unknownAs == FALSE) {
+            return simplifyAnd2ForUnknownAsFalse(terms, notTerms);
+        }
+        return simplifyAnd2(terms, notTerms);
+    }
+
+    private void simplifyList(List<RexNode> terms, RexUnknownAs unknownAs) {
+        terms.replaceAll(e -> simplify(e, unknownAs));
+    }
+
+    private void simplifyAndTerms(List<RexNode> terms, RexUnknownAs unknownAs) {
+        RexSimplify simplify = this;
+        for (int i = 0; i < terms.size(); i++) {
+            RexNode t = terms.get(i);
+            if (Predicate.of(t) == null) {
+                continue;
+            }
+            terms.set(i, simplify.simplify(t, unknownAs));
+            RelOptPredicateList newPredicates =
+                    simplify.predicates.union(
+                            rexBuilder,
+                            RelOptPredicateList.of(rexBuilder, terms.subList(i, i + 1)));
+            simplify = simplify.withPredicates(newPredicates);
+        }
+        for (int i = 0; i < terms.size(); i++) {
+            RexNode t = terms.get(i);
+            if (Predicate.of(t) != null) {
+                continue;
+            }
+            terms.set(i, simplify.simplify(t, unknownAs));
+        }
+    }
+
+    private void simplifyOrTerms(List<RexNode> terms, RexUnknownAs unknownAs) {
+        // Suppose we are processing "e1(x) OR e2(x) OR e3(x)". When we are
+        // visiting "e3(x)" we know both "e1(x)" and "e2(x)" are not true (they
+        // may be unknown), because if either of them were true we would have
+        // stopped.
+        RexSimplify simplify = this;
+
+        // 'doneTerms' prevents us from visiting a term in both first and second
+        // loops. If we did this, the second visit would have a predicate saying
+        // that 'term' is false. Effectively, we sort terms: visiting
+        // 'allowedAsPredicate' terms in the first loop, and
+        // non-'allowedAsPredicate' in the second. Each term is visited once.
+        final BitSet doneTerms = new BitSet();
+        for (int i = 0; i < terms.size(); i++) {
+            final RexNode t = terms.get(i);
+            if (!simplify.allowedAsPredicateDuringOrSimplification(t)) {
+                continue;
+            }
+            doneTerms.set(i);
+            final RexNode t2 = simplify.simplify(t, unknownAs);
+            terms.set(i, t2);
+            final RexNode inverse = simplify.simplify(isNotTrue(t2), RexUnknownAs.UNKNOWN);
+            final RelOptPredicateList newPredicates =
+                    simplify.predicates.union(
+                            rexBuilder,
+                            RelOptPredicateList.of(rexBuilder, ImmutableList.of(inverse)));
+            simplify = simplify.withPredicates(newPredicates);
+        }
+        for (int i = 0; i < terms.size(); i++) {
+            final RexNode t = terms.get(i);
+            if (doneTerms.get(i)) {
+                continue; // we visited this term in the first loop
+            }
+            terms.set(i, simplify.simplify(t, unknownAs));
+        }
+    }
+
+    /**
+     * Decides whether the given node could be used as a predicate during the simplification of
+     * other OR operands.
+     */
+    private boolean allowedAsPredicateDuringOrSimplification(final RexNode t) {
+        Predicate predicate = Predicate.of(t);
+        return predicate != null && predicate.allowedInOr(predicates);
+    }
+
+    private RexNode simplifyNot(RexCall call, RexUnknownAs unknownAs) {
+        final RexNode a = call.getOperands().get(0);
+        final List<RexNode> newOperands;
+        switch (a.getKind()) {
+            case NOT:
+                // NOT NOT x ==> x
+                return simplify(((RexCall) a).getOperands().get(0), unknownAs);
+
+            case SEARCH:
+                // NOT SEARCH(x, Sarg[(-inf, 10) OR NULL) ==> SEARCH(x, Sarg[[10, +inf)])
+                final RexCall call2 = (RexCall) a;
+                final RexNode ref = call2.operands.get(0);
+                final RexLiteral literal = (RexLiteral) call2.operands.get(1);
+                final Sarg sarg = literal.getValueAs(Sarg.class);
+                return simplifySearch(
+                        call2.clone(
+                                call2.type,
+                                ImmutableList.of(
+                                        ref,
+                                        rexBuilder.makeLiteral(
+                                                requireNonNull(sarg, "sarg").negate(),
+                                                literal.getType(),
+                                                literal.getTypeName()))),
+                        unknownAs.negate());
+
+            case LITERAL:
+                if (a.getType().getSqlTypeName() == SqlTypeName.BOOLEAN
+                        && !RexLiteral.isNullLiteral(a)) {
+                    return rexBuilder.makeLiteral(!RexLiteral.booleanValue(a));
+                }
+                break;
+
+            case AND:
+                // NOT distributivity for AND
+                newOperands = new ArrayList<>();
+                for (RexNode operand : ((RexCall) a).getOperands()) {
+                    newOperands.add(simplify(not(operand), unknownAs));
+                }
+                return simplify(
+                        rexBuilder.makeCall(
+                                call.getParserPosition(), SqlStdOperatorTable.OR, newOperands),
+                        unknownAs);
+
+            case OR:
+                // NOT distributivity for OR
+                newOperands = new ArrayList<>();
+                for (RexNode operand : ((RexCall) a).getOperands()) {
+                    newOperands.add(simplify(not(operand), unknownAs));
+                }
+                return simplify(
+                        rexBuilder.makeCall(
+                                call.getParserPosition(), SqlStdOperatorTable.AND, newOperands),
+                        unknownAs);
+
+            case CASE:
+                newOperands = new ArrayList<>();
+                List<RexNode> operands = ((RexCall) a).getOperands();
+                for (int i = 0; i < operands.size(); i += 2) {
+                    if (i + 1 == operands.size()) {
+                        newOperands.add(not(operands.get(i)));
+                    } else {
+                        newOperands.add(operands.get(i));
+                        newOperands.add(not(operands.get(i + 1)));
+                    }
+                }
+                return simplify(
+                        rexBuilder.makeCall(
+                                call.getParserPosition(), SqlStdOperatorTable.CASE, newOperands),
+                        unknownAs);
+
+            case IN:
+            case NOT_IN:
+                // do not try to negate
+                break;
+
+            default:
+                final SqlKind negateKind = a.getKind().negate();
+                if (a.getKind() != negateKind) {
+                    return simplify(
+                            rexBuilder.makeCall(
+                                    call.getParserPosition(),
+                                    RexUtil.op(negateKind),
+                                    ((RexCall) a).getOperands()),
+                            unknownAs);
+                }
+                final SqlKind negateKind2 = a.getKind().negateNullSafe();
+                if (a.getKind() != negateKind2) {
+                    return simplify(
+                            rexBuilder.makeCall(
+                                    call.getParserPosition(),
+                                    RexUtil.op(negateKind2),
+                                    ((RexCall) a).getOperands()),
+                            unknownAs);
+                }
+        }
+
+        RexNode a2 = simplify(a, unknownAs.negate());
+        if (a == a2) {
+            return call;
+        }
+        return not(a2);
+    }
+
+    private RexNode simplifyUnaryMinus(RexCall call, RexUnknownAs unknownAs) {
+        final RexNode a = call.getOperands().get(0);
+        if (a.getKind() == SqlKind.MINUS_PREFIX) {
+            // -(-(x)) ==> x
+            return simplify(((RexCall) a).getOperands().get(0), unknownAs);
+        }
+        return simplifyGenericNode(call);
+    }
+
+    private RexNode simplifyUnaryPlus(RexCall call, RexUnknownAs unknownAs) {
+        return simplify(call.getOperands().get(0), unknownAs);
+    }
+
+    private RexNode simplifyIs(RexCall call, RexUnknownAs unknownAs) {
+        final SqlKind kind = call.getKind();
+        final RexNode a = call.getOperands().get(0);
+        final RexNode simplified = simplifyIs1(kind, a, unknownAs);
+        return simplified == null ? call : simplified;
+    }
+
+    private @Nullable RexNode simplifyIs1(SqlKind kind, RexNode a, RexUnknownAs unknownAs) {
+        // UnknownAs.FALSE corresponds to x IS TRUE evaluation
+        // UnknownAs.TRUE to x IS NOT FALSE
+        // Note that both UnknownAs.TRUE and UnknownAs.FALSE only changes the meaning of Unknown
+        // (1) if we are already in UnknownAs.FALSE mode; x IS TRUE can be simplified to x
+        // (2) similarly in UnknownAs.TRUE mode; x IS NOT FALSE can be simplified to x
+        // (3) x IS FALSE could be rewritten to (NOT x) IS TRUE and from there the 1. rule applies
+        // (4) x IS NOT TRUE can be rewritten to (NOT x) IS NOT FALSE and from there the 2. rule
+        // applies
+        if (kind == SqlKind.IS_TRUE && unknownAs == RexUnknownAs.FALSE) {
+            return simplify(a, unknownAs);
+        }
+        if (kind == SqlKind.IS_FALSE && unknownAs == RexUnknownAs.FALSE) {
+            return simplify(not(a), unknownAs);
+        }
+        if (kind == SqlKind.IS_NOT_FALSE && unknownAs == RexUnknownAs.TRUE) {
+            return simplify(a, unknownAs);
+        }
+        if (kind == SqlKind.IS_NOT_TRUE && unknownAs == RexUnknownAs.TRUE) {
+            return simplify(not(a), unknownAs);
+        }
+        final RexNode pred = simplifyIsPredicate(kind, a);
+        if (pred != null) {
+            return pred;
+        }
+
+        return simplifyIs2(kind, a, unknownAs);
+    }
+
+    private @Nullable RexNode simplifyIsPredicate(SqlKind kind, RexNode a) {
+        if (!(RexUtil.isReferenceOrAccess(a, true) || RexUtil.isDeterministic(a))) {
+            return null;
+        }
+
+        for (RexNode p : predicates.pulledUpPredicates) {
+            IsPredicate pred = IsPredicate.of(p);
+            if (pred == null || !a.equals(pred.ref)) {
+                continue;
+            }
+            if (kind == pred.kind) {
+                return rexBuilder.makeLiteral(true);
+            }
+        }
+        return null;
+    }
+
+    private @Nullable RexNode simplifyIs2(SqlKind kind, RexNode a, RexUnknownAs unknownAs) {
+        final RexNode simplified;
+        switch (kind) {
+            case IS_NULL:
+                // x IS NULL ==> FALSE (if x is not nullable)
+                validateStrongPolicy(a);
+                simplified = simplifyIsNull(a);
+                if (simplified != null) {
+                    return simplified;
+                }
+                break;
+            case IS_NOT_NULL:
+                // x IS NOT NULL ==> TRUE (if x is not nullable)
+                validateStrongPolicy(a);
+                simplified = simplifyIsNotNull(a);
+                if (simplified != null) {
+                    return simplified;
+                }
+                break;
+
+            case IS_TRUE:
+                // x IS TRUE ==> x (if x is not nullable)
+                if (predicates.isEffectivelyNotNull(a)) {
+                    return simplify(a, unknownAs);
+                }
+                simplified = simplify(a, RexUnknownAs.FALSE);
+                if (simplified == a) {
+                    return null;
+                }
+                return isTrue(simplified);
+
+            case IS_NOT_FALSE:
+                // x IS NOT FALSE ==> x (if x is not nullable)
+                if (predicates.isEffectivelyNotNull(a)) {
+                    return simplify(a, unknownAs);
+                }
+                simplified = simplify(a, RexUnknownAs.TRUE);
+                if (simplified == a) {
+                    return null;
+                }
+                return isNotFalse(simplified);
+
+            case IS_FALSE:
+            case IS_NOT_TRUE:
+                // x IS NOT TRUE ==> NOT x (if x is not nullable)
+                // x IS FALSE ==> NOT x (if x is not nullable)
+                if (predicates.isEffectivelyNotNull(a)) {
+                    return simplify(not(a), unknownAs);
+                }
+                break;
+
+            default:
+                break;
+        }
+        switch (a.getKind()) {
+            case NOT:
+                // (NOT x) IS TRUE ==> x IS FALSE
+                // Similarly for IS NOT TRUE, IS FALSE, etc.
+                //
+                // Note that
+                //   (NOT x) IS TRUE !=> x IS FALSE
+                // because of null values.
+                final SqlOperator notKind = RexUtil.op(kind.negateNullSafe());
+                final RexNode arg = ((RexCall) a).operands.get(0);
+                return simplify(rexBuilder.makeCall(notKind, arg), UNKNOWN);
+            default:
+                break;
+        }
+        final RexNode a2 = simplify(a, UNKNOWN);
+        if (a != a2) {
+            return rexBuilder.makeCall(RexUtil.op(kind), ImmutableList.of(a2));
+        }
+        return null; // cannot be simplified
+    }
+
+    private @Nullable RexNode simplifyIsNotNull(RexNode a) {
+        // Simplify the argument first,
+        // call ourselves recursively to see whether we can make more progress.
+        // For example, given
+        // "(CASE WHEN FALSE THEN 1 ELSE 2) IS NOT NULL" we first simplify the
+        // argument to "2", and only then we can simplify "2 IS NOT NULL" to "TRUE".
+        a = simplify(a, UNKNOWN);
+        if (!a.getType().isNullable() && isSafeExpression(a)) {
+            return rexBuilder.makeLiteral(true);
+        }
+        if (RexUtil.isLosslessCast(a)) {
+            if (!a.getType().isNullable()) {
+                return rexBuilder.makeLiteral(true);
+            }
+            return rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, RexUtil.removeCast(a));
+        }
+        if (predicates.pulledUpPredicates.contains(a)) {
+            return rexBuilder.makeLiteral(true);
+        }
+        if (hasCustomNullabilityRules(a.getKind())) {
+            return null;
+        }
+        switch (Strong.policy(a)) {
+            case NOT_NULL:
+                return rexBuilder.makeLiteral(true);
+            case ANY:
+                // "f" is a strong operator, so "f(operand0, operand1) IS NOT NULL"
+                // simplifies to "operand0 IS NOT NULL AND operand1 IS NOT NULL"
+                final List<RexNode> operands = new ArrayList<>();
+                for (RexNode operand : ((RexCall) a).getOperands()) {
+                    final RexNode simplified = simplifyIsNotNull(operand);
+                    if (simplified == null) {
+                        operands.add(rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, operand));
+                    } else if (simplified.isAlwaysFalse()) {
+                        return rexBuilder.makeLiteral(false);
+                    } else {
+                        operands.add(simplified);
+                    }
+                }
+                return RexUtil.composeConjunction(rexBuilder, operands);
+            case CUSTOM:
+                switch (a.getKind()) {
+                    case LITERAL:
+                        return rexBuilder.makeLiteral(!((RexLiteral) a).isNull());
+                    default:
+                        throw new AssertionError(
+                                "every CUSTOM policy needs a handler, " + a.getKind());
+                }
+            case AS_IS:
+            default:
+                return null;
+        }
+    }
+
+    private @Nullable RexNode simplifyIsNull(RexNode a) {
+        // Simplify the argument first,
+        // call ourselves recursively to see whether we can make more progress.
+        // For example, given
+        // "(CASE WHEN FALSE THEN 1 ELSE 2) IS NULL" we first simplify the
+        // argument to "2", and only then we can simplify "2 IS NULL" to "FALSE".
+        a = simplify(a, UNKNOWN);
+        if (!a.getType().isNullable() && isSafeExpression(a)) {
+            return rexBuilder.makeLiteral(false);
+        }
+        if (RexUtil.isLosslessCast(a)) {
+            if (!a.getType().isNullable()) {
+                return rexBuilder.makeLiteral(false);
+            }
+            return rexBuilder.makeCall(SqlStdOperatorTable.IS_NULL, RexUtil.removeCast(a));
+        }
+        if (RexUtil.isNull(a)) {
+            return rexBuilder.makeLiteral(true);
+        }
+        if (hasCustomNullabilityRules(a.getKind())) {
+            return null;
+        }
+        switch (Strong.policy(a)) {
+            case NOT_NULL:
+                return rexBuilder.makeLiteral(false);
+            case ANY:
+                // "f" is a strong operator, so "f(operand0, operand1) IS NULL" simplifies
+                // to "operand0 IS NULL OR operand1 IS NULL"
+                final List<RexNode> operands = new ArrayList<>();
+                for (RexNode operand : ((RexCall) a).getOperands()) {
+                    final RexNode simplified = simplifyIsNull(operand);
+                    if (simplified == null) {
+                        operands.add(rexBuilder.makeCall(SqlStdOperatorTable.IS_NULL, operand));
+                    } else {
+                        operands.add(simplified);
+                    }
+                }
+                return RexUtil.composeDisjunction(rexBuilder, operands, false);
+            case AS_IS:
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * Validates strong policy for specified {@link RexNode}.
+     *
+     * @param rexNode Rex node to validate the strong policy
+     * @throws AssertionError If the validation fails
+     */
+    private static void validateStrongPolicy(RexNode rexNode) {
+        if (hasCustomNullabilityRules(rexNode.getKind())) {
+            return;
+        }
+        switch (Strong.policy(rexNode)) {
+            case NOT_NULL:
+                assert !rexNode.getType().isNullable();
+                break;
+            case ANY:
+                List<RexNode> operands = ((RexCall) rexNode).getOperands();
+                if (rexNode.getType().isNullable()) {
+                    assert operands.stream()
+                            .map(RexNode::getType)
+                            .anyMatch(RelDataType::isNullable);
+                } else {
+                    assert operands.stream()
+                            .map(RexNode::getType)
+                            .noneMatch(RelDataType::isNullable);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Returns {@code true} if specified {@link SqlKind} has custom nullability rules which depend
+     * not only on the nullability of input operands.
+     *
+     * <p>For example, CAST may be used to change the nullability of its operand type, so it may be
+     * nullable, though the argument type was non-nullable.
+     *
+     * @param sqlKind Sql kind to check
+     * @return {@code true} if specified {@link SqlKind} has custom nullability rules
+     */
+    private static boolean hasCustomNullabilityRules(SqlKind sqlKind) {
+        switch (sqlKind) {
+            case CAST:
+            case ITEM:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private RexNode simplifyCoalesce(RexCall call) {
+        final Set<RexNode> operandSet = new HashSet<>();
+        final List<RexNode> operands = new ArrayList<>();
+        for (RexNode operand : call.getOperands()) {
+            operand = simplify(operand, UNKNOWN);
+            if (!RexUtil.isNull(operand) && operandSet.add(operand)) {
+                operands.add(operand);
+            }
+            if (!operand.getType().isNullable()) {
+                break;
+            }
+        }
+        switch (operands.size()) {
+            case 0:
+                return rexBuilder.makeNullLiteral(call.type);
+            case 1:
+                return operands.get(0);
+            default:
+                if (operands.equals(call.operands)) {
+                    return call;
+                }
+                return call.clone(call.type, operands);
+        }
+    }
+
+    private RexNode simplifyCase(RexCall call, RexUnknownAs unknownAs) {
+        List<CaseBranch> inputBranches =
+                CaseBranch.fromCaseOperands(rexBuilder, new ArrayList<>(call.getOperands()));
+
+        // run simplification on all operands
+        RexSimplify condSimplifier = this.withPredicates(RelOptPredicateList.EMPTY);
+        RexSimplify valueSimplifier = this;
+        RelDataType caseType = call.getType();
+
+        boolean conditionNeedsSimplify = false;
+        CaseBranch lastBranch = null;
+        List<CaseBranch> branches = new ArrayList<>();
+        for (CaseBranch inputBranch : inputBranches) {
+            // simplify the condition
+            RexNode newCond = condSimplifier.simplify(inputBranch.cond, RexUnknownAs.FALSE);
+            if (newCond.isAlwaysFalse()) {
+                // If the condition is false, we do not need to add it
+                continue;
+            }
+
+            // simplify the value
+            RexNode newValue = valueSimplifier.simplify(inputBranch.value, unknownAs);
+
+            // create new branch
+            if (lastBranch != null) {
+                if (lastBranch.value.equals(newValue) && isSafeExpression(newCond)) {
+                    // in this case, last branch and new branch have the same conclusion,
+                    // hence we create a new composite condition and we do not add it to
+                    // the final branches for the time being
+                    newCond = rexBuilder.makeCall(SqlStdOperatorTable.OR, lastBranch.cond, newCond);
+                    conditionNeedsSimplify = true;
+                } else {
+                    // if we reach here, the new branch is not mergeable with the last one,
+                    // hence we are going to add the last branch to the final branches.
+                    // if the last branch was merged, then we will simplify it first.
+                    // otherwise, we just add it
+                    CaseBranch branch =
+                            generateBranch(conditionNeedsSimplify, condSimplifier, lastBranch);
+                    if (!branch.cond.isAlwaysFalse()) {
+                        // If the condition is not false, we add it to the final result
+                        branches.add(branch);
+                        if (branch.cond.isAlwaysTrue()) {
+                            // If the condition is always true, we are done
+                            lastBranch = null;
+                            break;
+                        }
+                    }
+                    conditionNeedsSimplify = false;
+                }
+            }
+            lastBranch = new CaseBranch(newCond, newValue);
+
+            if (newCond.isAlwaysTrue()) {
+                // If the condition is always true, we are done (useful in first loop iteration)
+                break;
+            }
+        }
+        if (lastBranch != null) {
+            // we need to add the last pending branch once we have finished
+            // with the for loop
+            CaseBranch branch = generateBranch(conditionNeedsSimplify, condSimplifier, lastBranch);
+            if (!branch.cond.isAlwaysFalse()) {
+                branches.add(branch);
+            }
+        }
+
+        if (branches.size() == 1) {
+            // we can just return the value in this case (matching the case type)
+            final RexNode value = branches.get(0).value;
+            if (sameTypeOrNarrowsNullability(caseType, value.getType())) {
+                return value;
+            } else {
+                return rexBuilder.makeAbstractCast(
+                        call.getParserPosition(), caseType, value, false);
+            }
+        }
+
+        if (call.getType().getSqlTypeName() == SqlTypeName.BOOLEAN) {
+            final RexNode result = simplifyBooleanCase(rexBuilder, branches, unknownAs, caseType);
+            if (result != null) {
+                if (sameTypeOrNarrowsNullability(caseType, result.getType())) {
+                    return simplify(result, unknownAs);
+                } else {
+                    // If the simplification would widen the nullability
+                    RexNode simplified = simplify(result, UNKNOWN);
+                    if (!simplified.getType().isNullable()) {
+                        return simplified;
+                    } else {
+                        return rexBuilder.makeCast(
+                                call.getParserPosition(), call.getType(), simplified);
+                    }
+                }
+            }
+        }
+        List<RexNode> newOperands = CaseBranch.toCaseOperands(branches);
+        if (newOperands.equals(call.getOperands())) {
+            return call;
+        }
+        return rexBuilder.makeCall(call.getParserPosition(), SqlStdOperatorTable.CASE, newOperands);
+    }
+
+    /**
+     * If boolean is true, simplify cond in input branch and return new branch. Otherwise, simply
+     * return input branch.
+     */
+    private static CaseBranch generateBranch(
+            boolean simplifyCond, RexSimplify simplifier, CaseBranch branch) {
+        if (simplifyCond) {
+            // the previous branch was merged, time to simplify it and
+            // add it to the final result
+            return new CaseBranch(
+                    simplifier.simplify(branch.cond, RexUnknownAs.FALSE), branch.value);
+        }
+        return branch;
+    }
+
+    /** Return if the new type is the same and at most narrows the nullability. */
+    private boolean sameTypeOrNarrowsNullability(RelDataType oldType, RelDataType newType) {
+        return oldType.equals(newType)
+                || (SqlTypeUtil.equalSansNullability(rexBuilder.typeFactory, oldType, newType)
+                        && oldType.isNullable());
+    }
+
+    /** Object to describe a CASE branch. */
+    static final class CaseBranch {
+
+        private final RexNode cond;
+        private final RexNode value;
+
+        CaseBranch(RexNode cond, RexNode value) {
+            this.cond = cond;
+            this.value = value;
+        }
+
+        @Override
+        public String toString() {
+            return cond + " => " + value;
+        }
+
+        /** Given "CASE WHEN p1 THEN v1 ... ELSE e END" returns [(p1, v1), ..., (true, e)]. */
+        private static List<CaseBranch> fromCaseOperands(
+                RexBuilder rexBuilder, List<RexNode> operands) {
+            List<CaseBranch> ret = new ArrayList<>();
+            for (int i = 0; i < operands.size() - 1; i += 2) {
+                ret.add(new CaseBranch(operands.get(i), operands.get(i + 1)));
+            }
+            ret.add(new CaseBranch(rexBuilder.makeLiteral(true), Util.last(operands)));
+            return ret;
+        }
+
+        private static List<RexNode> toCaseOperands(List<CaseBranch> branches) {
+            List<RexNode> ret = new ArrayList<>();
+            for (int i = 0; i < branches.size() - 1; i++) {
+                CaseBranch branch = branches.get(i);
+                ret.add(branch.cond);
+                ret.add(branch.value);
+            }
+            CaseBranch lastBranch = Util.last(branches);
+            assert lastBranch.cond.isAlwaysTrue();
+            ret.add(lastBranch.value);
+            return ret;
+        }
+    }
+
+    /** Decides whether it is safe to flatten the given CASE part into ANDs/ORs. */
+    enum SafeRexVisitor implements RexVisitor<Boolean> {
+        INSTANCE;
+
+        @SuppressWarnings("ImmutableEnumChecker")
+        private final Set<SqlKind> safeOps;
+
+        @SuppressWarnings("ImmutableEnumChecker")
+        private final ImmutableSet<SqlOperator> safeOperators;
+
+        SafeRexVisitor() {
+            ImmutableSet.Builder<SqlOperator> builder = ImmutableSet.builder();
+            builder.addAll(SqlStdOperatorTable.QUANTIFY_OPERATORS);
+            safeOperators = builder.build();
+
+            Set<SqlKind> safeOps = EnumSet.noneOf(SqlKind.class);
+            safeOps.addAll(SqlKind.COMPARISON);
+            safeOps.add(SqlKind.ARRAY_VALUE_CONSTRUCTOR);
+            safeOps.add(SqlKind.PLUS_PREFIX);
+            safeOps.add(SqlKind.MINUS_PREFIX);
+            safeOps.add(SqlKind.CHECKED_MINUS_PREFIX);
+            safeOps.add(SqlKind.PLUS);
+            safeOps.add(SqlKind.MINUS);
+            safeOps.add(SqlKind.TIMES);
+            safeOps.add(SqlKind.CHECKED_PLUS);
+            safeOps.add(SqlKind.CHECKED_MINUS);
+            safeOps.add(SqlKind.CHECKED_TIMES);
+            safeOps.add(SqlKind.IS_FALSE);
+            safeOps.add(SqlKind.IS_NOT_FALSE);
+            safeOps.add(SqlKind.IS_TRUE);
+            safeOps.add(SqlKind.IS_NOT_TRUE);
+            safeOps.add(SqlKind.IS_NULL);
+            safeOps.add(SqlKind.IS_NOT_NULL);
+            safeOps.add(SqlKind.IS_DISTINCT_FROM);
+            safeOps.add(SqlKind.IS_NOT_DISTINCT_FROM);
+            safeOps.add(SqlKind.IN);
+            safeOps.add(SqlKind.SEARCH);
+            safeOps.add(SqlKind.OR);
+            safeOps.add(SqlKind.AND);
+            safeOps.add(SqlKind.NOT);
+            safeOps.add(SqlKind.CASE);
+            safeOps.add(SqlKind.LIKE);
+            safeOps.add(SqlKind.COALESCE);
+            safeOps.add(SqlKind.TRIM);
+            safeOps.add(SqlKind.LTRIM);
+            safeOps.add(SqlKind.RTRIM);
+            safeOps.add(SqlKind.BETWEEN);
+            safeOps.add(SqlKind.CEIL);
+            safeOps.add(SqlKind.FLOOR);
+            safeOps.add(SqlKind.REVERSE);
+            safeOps.add(SqlKind.TIMESTAMP_ADD);
+            safeOps.add(SqlKind.TIMESTAMP_DIFF);
+            this.safeOps = Sets.immutableEnumSet(safeOps);
+        }
+
+        @Override
+        public Boolean visitInputRef(RexInputRef inputRef) {
+            return true;
+        }
+
+        @Override
+        public Boolean visitLocalRef(RexLocalRef localRef) {
+            return false;
+        }
+
+        @Override
+        public Boolean visitLiteral(RexLiteral literal) {
+            return true;
+        }
+
+        @Override
+        public Boolean visitCall(RexCall call) {
+            SqlKind sqlKind = call.getKind();
+            SqlOperator sqlOperator = call.getOperator();
+
+            switch (sqlKind) {
+                case DIVIDE:
+                case MOD:
+                    List<RexNode> operands = call.getOperands();
+                    boolean isSafe =
+                            RexVisitorImpl.visitArrayAnd(this, ImmutableList.of(operands.get(0)));
+                    if (!isSafe) {
+                        return false;
+                    }
+                    if (operands.get(1) instanceof RexLiteral) {
+                        RexLiteral literal = (RexLiteral) operands.get(1);
+                        return RexUtil.isNullLiteral(literal, true);
+                    }
+                    return false;
+                default:
+                    break;
+            }
+
+            if (sqlOperator.isSafeOperator()
+                    || RexUtil.isLosslessCast(call)
+                    || safeOps.contains(sqlKind)
+                    || safeOperators.contains(sqlOperator)) {
+                return RexVisitorImpl.visitArrayAnd(this, call.operands);
+            }
+
+            return false;
+        }
+
+        @Override
+        public Boolean visitOver(RexOver over) {
+            return false;
+        }
+
+        @Override
+        public Boolean visitCorrelVariable(RexCorrelVariable correlVariable) {
+            return false;
+        }
+
+        @Override
+        public Boolean visitDynamicParam(RexDynamicParam dynamicParam) {
+            return false;
+        }
+
+        @Override
+        public Boolean visitRangeRef(RexRangeRef rangeRef) {
+            return false;
+        }
+
+        @Override
+        public Boolean visitFieldAccess(RexFieldAccess fieldAccess) {
+            return true;
+        }
+
+        @Override
+        public Boolean visitSubQuery(RexSubQuery subQuery) {
+            return false;
+        }
+
+        @Override
+        public Boolean visitTableInputRef(RexTableInputRef fieldRef) {
+            return false;
+        }
+
+        @Override
+        public Boolean visitPatternFieldRef(RexPatternFieldRef fieldRef) {
+            return false;
+        }
+
+        @Override
+        public Boolean visitLambda(RexLambda lambda) {
+            return lambda.getExpression().accept(this);
+        }
+
+        @Override
+        public Boolean visitLambdaRef(RexLambdaRef lambdaRef) {
+            return true;
+        }
+
+        @Override
+        public Boolean visitNodeAndFieldIndex(RexNodeAndFieldIndex nodeAndFieldIndex) {
+            return true;
+        }
+    }
+
+    /**
+     * Analyzes a given {@link RexNode} and decides whenever it is safe to unwind.
+     *
+     * <p>"Safe" means that it only contains a combination of known good operators.
+     *
+     * <p>Division is an unsafe operator; consider the following:
+     *
+     * <pre>case when a &gt; 0 then 1 / a else null end</pre>
+     */
+    static boolean isSafeExpression(RexNode r) {
+        return r.accept(SafeRexVisitor.INSTANCE);
+    }
+
+    private @Nullable RexNode simplifyBooleanCase(
+            RexBuilder rexBuilder,
+            List<CaseBranch> inputBranches,
+            @SuppressWarnings("unused") RexUnknownAs unknownAs,
+            RelDataType branchType) {
+        RexNode result;
+
+        // prepare all condition/branches for boolean interpretation
+        // It's done here make these interpretation changes available to case2or simplifications
+        // but not interfere with the normal simplification recursion
+        List<CaseBranch> branches = new ArrayList<>();
+        for (CaseBranch branch : inputBranches) {
+            if ((!branches.isEmpty() && !isSafeExpression(branch.cond))
+                    || !isSafeExpression(branch.value)) {
+                return null;
+            }
+            final RexNode cond = isTrue(branch.cond);
+            final RexNode value;
+            if (!branchType.equals(branch.value.getType())) {
+                value = rexBuilder.makeAbstractCast(branchType, branch.value, false);
+            } else {
+                value = branch.value;
+            }
+            branches.add(new CaseBranch(cond, value));
+        }
+
+        result = simplifyBooleanCaseGeneric(rexBuilder, branches);
+        return result;
+    }
+
+    /**
+     * Generic boolean case simplification.
+     *
+     * <p>Rewrites:
+     *
+     * <pre>
+     * CASE
+     *   WHEN p1 THEN x
+     *   WHEN p2 THEN y
+     *   ELSE z
+     * END
+     * </pre>
+     *
+     * to
+     *
+     * <pre>(p1 and x) or (p2 and y and not(p1)) or (true and z and not(p1) and not(p2))</pre>
+     */
+    private static RexNode simplifyBooleanCaseGeneric(
+            RexBuilder rexBuilder, List<CaseBranch> branches) {
+
+        boolean booleanBranches =
+                branches.stream()
+                        .allMatch(
+                                branch ->
+                                        branch.value.isAlwaysTrue()
+                                                || branch.value.isAlwaysFalse());
+        final List<RexNode> terms = new ArrayList<>();
+        final List<RexNode> notTerms = new ArrayList<>();
+        for (CaseBranch branch : branches) {
+            boolean useBranch = !branch.value.isAlwaysFalse();
+            if (useBranch) {
+                final RexNode branchTerm;
+                if (branch.value.isAlwaysTrue()) {
+                    branchTerm = branch.cond;
+                } else {
+                    branchTerm =
+                            rexBuilder.makeCall(SqlStdOperatorTable.AND, branch.cond, branch.value);
+                }
+                terms.add(RexUtil.andNot(rexBuilder, branchTerm, notTerms));
+            }
+            if (booleanBranches && useBranch) {
+                // we are safe to ignore this branch because for boolean true branches:
+                // a || (b && !a) === a || b
+            } else {
+                notTerms.add(branch.cond);
+            }
+        }
+        return RexUtil.composeDisjunction(rexBuilder, terms);
+    }
+
+    @Deprecated // to be removed before 2.0
+    public RexNode simplifyAnd(RexCall e) {
+        ensureParanoidOff();
+        return simplifyAnd(e, defaultUnknownAs);
+    }
+
+    RexNode simplifyAnd(RexCall e, RexUnknownAs unknownAs) {
+        List<RexNode> operands = RelOptUtil.conjunctions(e);
+
+        if (unknownAs == FALSE && predicateElimination) {
+            simplifyAndTerms(operands, FALSE);
+        } else {
+            simplifyList(operands, unknownAs);
+        }
+
+        final List<RexNode> terms = new ArrayList<>();
+        final List<RexNode> notTerms = new ArrayList<>();
+
+        final SargCollector sargCollector = new SargCollector(rexBuilder, true);
+        operands.forEach(t -> sargCollector.accept(t, terms));
+        if (sargCollector.needToFix()) {
+            operands.clear();
+            terms.forEach(t -> operands.add(SargCollector.fix(rexBuilder, t, unknownAs)));
+        }
+        terms.clear();
+
+        for (RexNode o : operands) {
+            RelOptUtil.decomposeConjunction(o, terms, notTerms);
+        }
+
+        switch (unknownAs) {
+            case FALSE:
+                return simplifyAnd2ForUnknownAsFalse(terms, notTerms, Comparable.class);
+            default:
+                break;
+        }
+        return simplifyAnd2(terms, notTerms);
+    }
+
+    // package-protected only to support a deprecated method; treat as private
+    RexNode simplifyAnd2(List<RexNode> terms, List<RexNode> notTerms) {
+        for (RexNode term : terms) {
+            if (term.isAlwaysFalse()) {
+                return rexBuilder.makeLiteral(false);
+            }
+        }
+        if (terms.isEmpty() && notTerms.isEmpty()) {
+            return rexBuilder.makeLiteral(true);
+        }
+        // If one of the not-disjunctions is a disjunction that is wholly
+        // contained in the disjunctions list, the expression is not
+        // satisfiable.
+        //
+        // Example #1. x AND y AND z AND NOT (x AND y)  - not satisfiable
+        // Example #2. x AND y AND NOT (x AND y)        - not satisfiable
+        // Example #3. x AND y AND NOT (x AND y AND z)  - may be satisfiable
+        List<RexNode> notSatisfiableNullables = null;
+        for (RexNode notDisjunction : notTerms) {
+            final List<RexNode> terms2 = RelOptUtil.conjunctions(notDisjunction);
+            if (!terms.containsAll(terms2)) {
+                // may be satisfiable ==> check other terms
+                continue;
+            }
+            if (!notDisjunction.getType().isNullable()) {
+                // x is NOT nullable, then x AND NOT(x) ==> FALSE
+                return rexBuilder.makeLiteral(false);
+            }
+            // x AND NOT(x) is UNKNOWN for NULL input
+            // So we search for the shortest notDisjunction then convert
+            // original expression to NULL and x IS NULL
+            if (notSatisfiableNullables == null) {
+                notSatisfiableNullables = new ArrayList<>();
+            }
+            notSatisfiableNullables.add(notDisjunction);
+        }
+
+        if (notSatisfiableNullables != null) {
+            // Remove the intersection of "terms" and "notTerms"
+            terms.removeAll(notSatisfiableNullables);
+            notTerms.removeAll(notSatisfiableNullables);
+
+            // The intersection simplify to "null and x1 is null and x2 is null..."
+            terms.add(rexBuilder.makeNullLiteral(notSatisfiableNullables.get(0).getType()));
+            for (RexNode notSatisfiableNullable : notSatisfiableNullables) {
+                terms.add(
+                        simplifyIs(
+                                (RexCall)
+                                        rexBuilder.makeCall(
+                                                SqlStdOperatorTable.IS_NULL,
+                                                notSatisfiableNullable),
+                                UNKNOWN));
+            }
+        }
+        // Add the NOT disjunctions back in.
+        for (RexNode notDisjunction : notTerms) {
+            terms.add(simplify(not(notDisjunction), UNKNOWN));
+        }
+        return RexUtil.composeConjunction(rexBuilder, terms);
+    }
+
+    /**
+     * As {@link #simplifyAnd2(List, List)} but we assume that if the expression returns UNKNOWN it
+     * will be interpreted as FALSE.
+     */
+    RexNode simplifyAnd2ForUnknownAsFalse(List<RexNode> terms, List<RexNode> notTerms) {
+        //noinspection unchecked
+        return simplifyAnd2ForUnknownAsFalse(terms, notTerms, Comparable.class);
+    }
+
+    private <C extends Comparable<C>> RexNode simplifyAnd2ForUnknownAsFalse(
+            List<RexNode> terms, List<RexNode> notTerms, Class<C> clazz) {
+        for (RexNode term : terms) {
+            if (term.isAlwaysFalse() || RexLiteral.isNullLiteral(term)) {
+                return rexBuilder.makeLiteral(false);
+            }
+        }
+        if (terms.isEmpty() && notTerms.isEmpty()) {
+            return rexBuilder.makeLiteral(true);
+        }
+        if (terms.size() == 1 && notTerms.isEmpty()) {
+            // Make sure "x OR y OR x" (a single-term conjunction) gets simplified.
+            return simplify(terms.get(0), FALSE);
+        }
+        // Try to simplify the expression
+        final Multimap<RexNode, Pair<RexNode, RexNode>> equalityTerms = ArrayListMultimap.create();
+        final Map<RexNode, Pair<Range<C>, List<RexNode>>> rangeTerms = new HashMap<>();
+        final Map<RexNode, RexLiteral> equalityConstantTerms = new HashMap<>();
+        final Set<RexNode> negatedTerms = new HashSet<>();
+        final Set<RexNode> nullOperands = new HashSet<>();
+        final Set<RexNode> notNullOperands = new LinkedHashSet<>();
+
+        // Add the predicates from the source to the range terms.
+        for (RexNode predicate : predicates.pulledUpPredicates) {
+            final Comparison comparison = Comparison.of(predicate);
+            if (comparison != null && comparison.kind != SqlKind.NOT_EQUALS) { // not supported yet
+                final C v0 = comparison.literal.getValueAs(clazz);
+                if (v0 != null) {
+                    final RexNode result =
+                            processRange(
+                                    rexBuilder,
+                                    terms,
+                                    rangeTerms,
+                                    predicate,
+                                    comparison.ref,
+                                    v0,
+                                    comparison.kind);
+                    if (result != null) {
+                        // Not satisfiable
+                        return result;
+                    }
+                }
+            }
+        }
+
+        for (int i = 0; i < terms.size(); i++) {
+            RexNode term = terms.get(i);
+            if (!RexUtil.isDeterministic(term)) {
+                continue;
+            }
+            // Simplify BOOLEAN expressions if possible
+            while (term.getKind() == SqlKind.EQUALS) {
+                RexCall call = (RexCall) term;
+                if (call.getOperands().get(0).isAlwaysTrue()) {
+                    term = call.getOperands().get(1);
+                    terms.set(i, term);
+                    continue;
+                } else if (call.getOperands().get(1).isAlwaysTrue()) {
+                    term = call.getOperands().get(0);
+                    terms.set(i, term);
+                    continue;
+                }
+                break;
+            }
+            switch (term.getKind()) {
+                case EQUALS:
+                case NOT_EQUALS:
+                case LESS_THAN:
+                case GREATER_THAN:
+                case LESS_THAN_OR_EQUAL:
+                case GREATER_THAN_OR_EQUAL:
+                    RexCall call = (RexCall) term;
+                    final RexNode left = call.getOperands().get(0);
+                    final RexNode right = call.getOperands().get(1);
+                    final Comparison comparison = Comparison.of(term);
+                    // Check for comparison with null values
+                    if (comparison != null && comparison.literal.getValue() == null) {
+                        return rexBuilder.makeLiteral(false);
+                    }
+                    // Check for equality on different constants. If the same ref or CAST(ref)
+                    // is equal to different constants, this condition cannot be satisfied,
+                    // and hence it can be evaluated to FALSE
+                    if (term.getKind() == SqlKind.EQUALS) {
+                        if (comparison != null) {
+                            final RexLiteral literal = comparison.literal;
+                            final RexLiteral prevLiteral =
+                                    equalityConstantTerms.put(comparison.ref, literal);
+
+                            if (prevLiteral != null
+                                    && literal.getType().equals(prevLiteral.getType())
+                                    && !literal.equals(prevLiteral)) {
+                                return rexBuilder.makeLiteral(false);
+                            }
+                        } else if (RexUtil.isReferenceOrAccess(left, true)
+                                && RexUtil.isReferenceOrAccess(right, true)) {
+                            equalityTerms.put(left, Pair.of(right, term));
+                        }
+                    }
+                    // Assume the expression a > 5 is part of a Filter condition.
+                    // Then we can derive the negated term: a <= 5.
+                    // But as the comparison is string based and thus operands order dependent,
+                    // we should also add the inverted negated term: 5 >= a.
+                    // Observe that for creating the inverted term we invert the list of operands.
+                    RexNode negatedTerm = RexUtil.negate(rexBuilder, call);
+                    if (negatedTerm != null) {
+                        negatedTerms.add(negatedTerm);
+                        RexNode invertNegatedTerm =
+                                RexUtil.invert(rexBuilder, (RexCall) negatedTerm);
+                        if (invertNegatedTerm != null) {
+                            negatedTerms.add(invertNegatedTerm);
+                        }
+                    }
+                    // Remove terms that are implied by predicates on the input,
+                    // or weaken terms that are partially implied.
+                    // E.g. given predicate "x >= 5" and term "x between 3 and 10"
+                    // we weaken to term to "x between 5 and 10".
+                    final RexNode term2 = simplifyUsingPredicates(term, clazz);
+                    if (term2 != term) {
+                        terms.set(i, term = term2);
+                    }
+                    // Range
+                    if (comparison != null
+                            && comparison.kind != SqlKind.NOT_EQUALS) { // not supported yet
+                        final C constant = comparison.literal.getValueAs(clazz);
+                        if (constant == null) {
+                            break;
+                        }
+                        final RexNode result =
+                                processRange(
+                                        rexBuilder,
+                                        terms,
+                                        rangeTerms,
+                                        term,
+                                        comparison.ref,
+                                        constant,
+                                        comparison.kind);
+                        if (result != null) {
+                            // Not satisfiable
+                            return result;
+                        }
+                    }
+                    break;
+                case IS_NOT_NULL:
+                    notNullOperands.add(((RexCall) term).getOperands().get(0));
+                    terms.remove(i);
+                    --i;
+                    break;
+                case IS_NULL:
+                    nullOperands.add(((RexCall) term).getOperands().get(0));
+                    break;
+                default:
+                    break;
+            }
+        }
+        // Check for equality of two refs wrt equality with constants
+        // Example #1. x=5 AND y=5 AND x=y : x=5 AND y=5
+        // Example #2. x=5 AND y=6 AND x=y - not satisfiable
+        for (RexNode ref1 : equalityTerms.keySet()) {
+            final RexLiteral literal1 = equalityConstantTerms.get(ref1);
+            if (literal1 == null) {
+                continue;
+            }
+            Collection<Pair<RexNode, RexNode>> references = equalityTerms.get(ref1);
+            for (Pair<RexNode, RexNode> ref2 : references) {
+                final RexLiteral literal2 = equalityConstantTerms.get(ref2.left);
+                if (literal2 == null) {
+                    continue;
+                }
+                if (literal1.getType().equals(literal2.getType()) && !literal1.equals(literal2)) {
+                    // If an expression is equal to two different constants,
+                    // it is not satisfiable
+                    return rexBuilder.makeLiteral(false);
+                }
+                // Otherwise we can remove the term, as we already know that
+                // the expression is equal to two constants
+                terms.remove(ref2.right);
+            }
+        }
+        // If one of the not-disjunctions is a disjunction that is wholly
+        // contained in the disjunctions list, the expression is not
+        // satisfiable.
+        //
+        // Example #1. x AND y AND z AND NOT (x AND y)  - not satisfiable
+        // Example #2. x AND y AND NOT (x AND y)        - not satisfiable
+        // Example #3. x AND y AND NOT (x AND y AND z)  - may be satisfiable
+        final Set<RexNode> termsSet = new HashSet<>(terms);
+        for (RexNode notDisjunction : notTerms) {
+            if (!RexUtil.isDeterministic(notDisjunction)) {
+                continue;
+            }
+            final List<RexNode> terms2Set = RelOptUtil.conjunctions(notDisjunction);
+            if (termsSet.containsAll(terms2Set)) {
+                return rexBuilder.makeLiteral(false);
+            }
+        }
+        // The negated terms: only deterministic expressions
+        for (RexNode negatedTerm : negatedTerms) {
+            if (termsSet.contains(negatedTerm)) {
+                return rexBuilder.makeLiteral(false);
+            }
+        }
+        // Add the NOT disjunctions back in.
+        for (RexNode notDisjunction : notTerms) {
+            terms.add(not(notDisjunction));
+        }
+        // Find operands that make will let whole expression evaluate to FALSE if set to NULL
+        final Set<RexNode> strongOperands = new HashSet<>();
+        for (RexNode term : terms) {
+            if (!RexUtil.isDeterministic(term)) {
+                continue;
+            }
+            final VariableCollector collector = new VariableCollector();
+            term.accept(collector);
+            for (RexInputRef ref : collector.refs) {
+                final boolean strong = Strong.isNotTrue(term, ImmutableBitSet.of(ref.index));
+                if (strong) {
+                    strongOperands.add(ref);
+                }
+            }
+            final RexUtil.FieldAccessFinder fieldAccessFinder = new RexUtil.FieldAccessFinder();
+            term.accept(fieldAccessFinder);
+            for (RexFieldAccess rexFieldAccess : fieldAccessFinder.getFieldAccessList()) {
+                final boolean strong = Strong.of(ImmutableSet.of(rexFieldAccess)).isNotTrue(term);
+                if (strong) {
+                    strongOperands.add(rexFieldAccess);
+                }
+            }
+        }
+        // If one column should be null and is in a comparison predicate,
+        // it is not satisfiable.
+        // Example. IS NULL(x) AND x < 5  - not satisfiable
+        if (!Collections.disjoint(nullOperands, strongOperands)) {
+            return rexBuilder.makeLiteral(false);
+        }
+        // Remove not necessary IS NOT NULL expressions.
+        // Example. IS NOT NULL(x) AND x < 5  : x < 5
+        for (RexNode operand : notNullOperands) {
+            if (!strongOperands.contains(operand)) {
+                terms.add(rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, operand));
+            }
+        }
+        return RexUtil.composeConjunction(rexBuilder, terms);
+    }
+
+    private <C extends Comparable<C>> RexNode simplifyUsingPredicates(RexNode e, Class<C> clazz) {
+        if (predicates.pulledUpPredicates.isEmpty()) {
+            return e;
+        }
+
+        final Comparison comparison = Comparison.of(e);
+        // Check for comparison with null values
+        if (comparison == null || comparison.literal.getValue() == null) {
+            return e;
+        }
+
+        final C v0 = comparison.literal.getValueAs(clazz);
+        if (v0 == null) {
+            return e;
+        }
+        final RangeSet<C> rangeSet = rangeSet(comparison.kind, v0);
+        final RangeSet<C> rangeSet2 =
+                residue(comparison.ref, rangeSet, predicates.pulledUpPredicates, clazz);
+        if (rangeSet2.isEmpty()) {
+            // Term is impossible to satisfy given these predicates
+            return rexBuilder.makeLiteral(false);
+        } else if (rangeSet2.equals(rangeSet)) {
+            // no change
+            return e;
+        } else if (rangeSet2.equals(RangeSets.rangeSetAll())) {
+            // Range is always satisfied given these predicates; but nullability might
+            // be problematic
+            return simplify(
+                    rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, comparison.ref),
+                    RexUnknownAs.UNKNOWN);
+        } else if (rangeSet2.asRanges().size() == 1
+                && Iterables.getOnlyElement(rangeSet2.asRanges()).hasLowerBound()
+                && Iterables.getOnlyElement(rangeSet2.asRanges()).hasUpperBound()
+                && Iterables.getOnlyElement(rangeSet2.asRanges())
+                        .lowerEndpoint()
+                        .equals(Iterables.getOnlyElement(rangeSet2.asRanges()).upperEndpoint())) {
+            final Range<C> r = Iterables.getOnlyElement(rangeSet2.asRanges());
+            // range is now a point; it's worth simplifying
+            return rexBuilder.makeCall(
+                    SqlStdOperatorTable.EQUALS,
+                    comparison.ref,
+                    rexBuilder.makeLiteral(
+                            r.lowerEndpoint(),
+                            comparison.literal.getType(),
+                            comparison.literal.getTypeName()));
+        } else {
+            // range has been reduced but it's not worth simplifying
+            return e;
+        }
+    }
+
+    /**
+     * Weakens a term so that it checks only what is not implied by predicates.
+     *
+     * <p>The term is broken into "ref comparison constant", for example "$0 &lt; 5".
+     *
+     * <p>Examples:
+     *
+     * <ul>
+     *   <li>{@code residue($0 < 10, [$0 < 5])} returns {@code true}
+     *   <li>{@code residue($0 < 10, [$0 < 20, $0 > 0])} returns {@code $0 < 10}
+     * </ul>
+     */
+    private static <C extends Comparable<C>> RangeSet<C> residue(
+            RexNode ref, RangeSet<C> r0, List<RexNode> predicates, Class<C> clazz) {
+        RangeSet<C> result = r0;
+        for (RexNode predicate : predicates) {
+            switch (predicate.getKind()) {
+                case EQUALS:
+                case NOT_EQUALS:
+                case LESS_THAN:
+                case LESS_THAN_OR_EQUAL:
+                case GREATER_THAN:
+                case GREATER_THAN_OR_EQUAL:
+                    final RexCall call = (RexCall) predicate;
+                    final Comparison comparison = Comparison.of(call);
+                    if (comparison != null && comparison.ref.equals(ref)) {
+                        final C c1 = comparison.literal.getValueAs(clazz);
+                        if (c1 == null) {
+                            throw new AssertionError(
+                                    "value must not be null in " + comparison.literal);
+                        }
+                        switch (predicate.getKind()) {
+                            case NOT_EQUALS:
+                                // We want to intersect result with the range set of everything but
+                                // c1. We subtract the point c1 from result, which is equivalent.
+                                final Range<C> pointRange = range(SqlKind.EQUALS, c1);
+                                final RangeSet<C> notEqualsRangeSet =
+                                        ImmutableRangeSet.of(pointRange).complement();
+                                if (result.enclosesAll(notEqualsRangeSet)) {
+                                    result = RangeSets.rangeSetAll();
+                                    continue;
+                                }
+                                result = RangeSets.minus(result, pointRange);
+                                break;
+                            default:
+                                final Range<C> r1 = range(comparison.kind, c1);
+                                if (result.encloses(r1)) {
+                                    // Given these predicates, term is always satisfied.
+                                    // e.g. r0 is "$0 < 10", r1 is "$0 < 5"
+                                    result = RangeSets.rangeSetAll();
+                                    continue;
+                                }
+                                result = result.subRangeSet(r1);
+                        }
+                        if (result.isEmpty()) {
+                            break; // short-cut
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Simplifies OR(x, x) into x, and similar. The simplified expression returns UNKNOWN values as
+     * is (not as FALSE).
+     */
+    @Deprecated // to be removed before 2.0
+    public RexNode simplifyOr(RexCall call) {
+        ensureParanoidOff();
+        return simplifyOr(call, UNKNOWN);
+    }
+
+    private RexNode simplifyOr(RexCall call, RexUnknownAs unknownAs) {
+        assert call.getKind() == SqlKind.OR;
+        final List<RexNode> terms0 = RelOptUtil.disjunctions(call);
+        final List<RexNode> terms;
+        if (predicateElimination) {
+            terms = Util.moveToHead(terms0, e -> e.getKind() == SqlKind.IS_NULL);
+            simplifyOrTerms(terms, unknownAs);
+        } else {
+            terms = terms0;
+            simplifyList(terms, unknownAs);
+        }
+        return simplifyOrs(terms, unknownAs);
+    }
+
+    /**
+     * Simplifies a list of terms and combines them into an OR. Modifies the list in place. The
+     * simplified expression returns UNKNOWN values as is (not as FALSE).
+     */
+    @Deprecated // to be removed before 2.0
+    public RexNode simplifyOrs(List<RexNode> terms) {
+        ensureParanoidOff();
+        return simplifyOrs(terms, UNKNOWN);
+    }
+
+    private void ensureParanoidOff() {
+        if (paranoid) {
+            throw new UnsupportedOperationException("Paranoid is not supported for this method");
+        }
+    }
+
+    /** Simplifies a list of terms and combines them into an OR. Modifies the list in place. */
+    private RexNode simplifyOrs(List<RexNode> terms, RexUnknownAs unknownAs) {
+        final SargCollector sargCollector = new SargCollector(rexBuilder, false);
+        final List<RexNode> newTerms = new ArrayList<>();
+        terms.forEach(t -> sargCollector.accept(t, newTerms));
+        if (sargCollector.needToFix()) {
+            terms.clear();
+            newTerms.forEach(t -> terms.add(SargCollector.fix(rexBuilder, t, unknownAs)));
+        }
+
+        // CALCITE-3198 Auxiliary map to simplify cases like:
+        //   X <> A OR X <> B => X IS NOT NULL or NULL
+        // The map key will be the 'X'; and the value the first call 'X<>A' that is found,
+        // or 'X IS NOT NULL' if a simplification takes place (because another 'X<>B' is found)
+        final Map<RexNode, RexNode> notEqualsComparisonMap = new HashMap<>();
+        final RexLiteral trueLiteral = rexBuilder.makeLiteral(true);
+        for (int i = 0; i < terms.size(); i++) {
+            final RexNode term = terms.get(i);
+            switch (term.getKind()) {
+                case LITERAL:
+                    if (RexLiteral.isNullLiteral(term)) {
+                        if (unknownAs == FALSE) {
+                            terms.remove(i);
+                            --i;
+                            continue;
+                        } else if (unknownAs == TRUE) {
+                            return trueLiteral;
+                        }
+                    } else {
+                        if (RexLiteral.booleanValue(term)) {
+                            return term; // true
+                        } else {
+                            terms.remove(i);
+                            --i;
+                            continue;
+                        }
+                    }
+                    break;
+                case NOT_EQUALS:
+                    final Comparison notEqualsComparison = Comparison.of(term);
+                    if (notEqualsComparison != null) {
+                        // We are dealing with a X<>A term, check if we saw before another
+                        // NOT_EQUALS involving X
+                        final RexNode prevNotEquals =
+                                notEqualsComparisonMap.get(notEqualsComparison.ref);
+                        if (prevNotEquals == null) {
+                            // This is the first NOT_EQUALS involving X, put it in the map
+                            notEqualsComparisonMap.put(notEqualsComparison.ref, term);
+                        } else {
+                            // There is already in the map another NOT_EQUALS involving X:
+                            //   - if it is already an IS_NOT_NULL: it was already simplified,
+                            // ignore this term
+                            //   - if it is not an IS_NOT_NULL (i.e. it is a NOT_EQUALS): check
+                            // comparison values
+                            if (prevNotEquals.getKind() != SqlKind.IS_NOT_NULL) {
+                                final Comparable comparable1 =
+                                        notEqualsComparison.literal.getValue();
+                                final Comparable comparable2 =
+                                        castNonNull(Comparison.of(prevNotEquals))
+                                                .literal
+                                                .getValue();
+                                //noinspection unchecked
+                                if (comparable1 != null
+                                        && comparable2 != null
+                                        && comparable1.compareTo(comparable2) != 0) {
+                                    // X <> A OR X <> B => X IS NOT NULL OR NULL
+                                    final RexNode isNotNull =
+                                            rexBuilder.makeCall(
+                                                    SqlStdOperatorTable.IS_NOT_NULL,
+                                                    notEqualsComparison.ref);
+                                    final RexNode constantNull =
+                                            rexBuilder.makeNullLiteral(trueLiteral.getType());
+                                    final RexNode newCondition =
+                                            simplify(
+                                                    rexBuilder.makeCall(
+                                                            SqlStdOperatorTable.OR,
+                                                            isNotNull,
+                                                            constantNull),
+                                                    unknownAs);
+                                    if (newCondition.isAlwaysTrue()) {
+                                        return trueLiteral;
+                                    }
+                                    notEqualsComparisonMap.put(notEqualsComparison.ref, isNotNull);
+                                    final int pos = terms.indexOf(prevNotEquals);
+                                    terms.set(pos, newCondition);
+                                }
+                            }
+                            terms.remove(i);
+                            --i;
+                            continue;
+                        }
+                    }
+                    break;
+                case IS_NOT_TRUE:
+                    RexNode arg = ((RexCall) term).getOperands().get(0);
+                    if (isSafeExpression(arg) && terms.contains(arg)) {
+                        return trueLiteral;
+                    }
+                    break;
+                case NOT:
+                    RexNode x = ((RexCall) term).getOperands().get(0);
+                    if (isSafeExpression(x) && terms.contains(x)) {
+                        if (!x.getType().isNullable()) {
+                            return trueLiteral;
+                        }
+
+                        final RexNode isNotNull =
+                                rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, x);
+                        terms.set(terms.indexOf(x), simplifyIs((RexCall) isNotNull, unknownAs));
+                        terms.set(i, rexBuilder.makeNullLiteral(x.getType()));
+                        i--;
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        return RexUtil.composeDisjunction(rexBuilder, terms);
+    }
+
+    private void verify(RexNode before, RexNode simplified, RexUnknownAs unknownAs) {
+        if (simplified.isAlwaysFalse() && before.isAlwaysTrue()) {
+            throw new AssertionError(
+                    "always true [" + before + "] simplified to always false [" + simplified + "]");
+        }
+        if (simplified.isAlwaysTrue() && before.isAlwaysFalse()) {
+            throw new AssertionError(
+                    "always false [" + before + "] simplified to always true [" + simplified + "]");
+        }
+        final RexAnalyzer foo0 = new RexAnalyzer(before, predicates);
+        final RexAnalyzer foo1 = new RexAnalyzer(simplified, predicates);
+        if (foo0.unsupportedCount > 0 || foo1.unsupportedCount > 0) {
+            // Analyzer cannot handle this expression currently
+            return;
+        }
+        if (!foo0.variables.containsAll(foo1.variables)) {
+            throw new AssertionError(
+                    "variable mismatch: "
+                            + before
+                            + " has "
+                            + foo0.variables
+                            + ", "
+                            + simplified
+                            + " has "
+                            + foo1.variables);
+        }
+        assignment_loop:
+        for (Map<RexNode, Comparable> map : foo0.assignments()) {
+            for (RexNode predicate : predicates.pulledUpPredicates) {
+                final Comparable v = RexInterpreter.evaluate(predicate, map);
+                if (!Boolean.TRUE.equals(v)) {
+                    continue assignment_loop;
+                }
+            }
+            Comparable v0 = RexInterpreter.evaluate(foo0.e, map);
+            if (v0 == null) {
+                throw new AssertionError("interpreter returned null for " + foo0.e);
+            }
+            Comparable v1 = RexInterpreter.evaluate(foo1.e, map);
+            if (v1 == null) {
+                throw new AssertionError("interpreter returned null for " + foo1.e);
+            }
+            if (before.getType().getSqlTypeName() == SqlTypeName.BOOLEAN) {
+                switch (unknownAs) {
+                    case FALSE:
+                    case TRUE:
+                        if (v0 == NullSentinel.INSTANCE) {
+                            v0 = unknownAs.toBoolean();
+                        }
+                        if (v1 == NullSentinel.INSTANCE) {
+                            v1 = unknownAs.toBoolean();
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+            if (!v0.equals(v1)) {
+                throw new AssertionError(
+                        "result mismatch (unknown as "
+                                + unknownAs
+                                + "): when applied to "
+                                + map
+                                + ",\n"
+                                + before
+                                + " yielded "
+                                + v0
+                                + ";\n"
+                                + simplified
+                                + " yielded "
+                                + v1);
+            }
+        }
+    }
+
+    private RexNode simplifySearch(RexCall call, RexUnknownAs unknownAs) {
+        assert call.getKind() == SqlKind.SEARCH;
+        final RexNode operand = call.getOperands().get(0);
+        final RexNode simplifiedOperand = simplify(operand, unknownAs);
+        final boolean operandUnchanged = operand.equals(simplifiedOperand);
+        final RexNode searchOperand = operandUnchanged ? operand : simplifiedOperand;
+        if (call.getOperands().get(1) instanceof RexLiteral) {
+            RexLiteral literal = (RexLiteral) call.getOperands().get(1);
+            final Sarg sarg = castNonNull(literal.getValueAs(Sarg.class));
+            if (sarg.isAll() || sarg.isNone()) {
+                RexNode rexNode = RexUtil.simpleSarg(rexBuilder, searchOperand, sarg, unknownAs);
+                return simplify(rexNode, unknownAs);
+            }
+            // Remove null from sarg if the left-hand side is never null
+            if (sarg.nullAs != UNKNOWN) {
+                final RexNode simplified = simplifyIs1(SqlKind.IS_NULL, searchOperand, unknownAs);
+                if (simplified != null && simplified.isAlwaysFalse()) {
+                    final Sarg sarg2 = Sarg.of(UNKNOWN, sarg.rangeSet);
+                    final RexLiteral literal2 =
+                            rexBuilder.makeLiteral(sarg2, literal.getType(), literal.getTypeName());
+                    // Now we've strengthened the Sarg, try to simplify again
+                    return simplifySearch(
+                            call.clone(call.type, ImmutableList.of(searchOperand, literal2)),
+                            unknownAs);
+                }
+            } else if (sarg.isPoints() && sarg.pointCount <= 1) {
+                // Expand "SEARCH(x, Sarg([point])" to "x = point"
+                // and "SEARCH(x, Sarg([])" to "false"
+                return RexUtil.expandSearch(rexBuilder, null, call);
+            }
+        }
+        return operandUnchanged
+                ? call
+                : call.clone(
+                        call.type, ImmutableList.of(simplifiedOperand, call.getOperands().get(1)));
+    }
+
+    private RexNode simplifyCast(RexCall e) {
+        RexNode operand = e.getOperands().get(0);
+        operand = simplify(operand, UNKNOWN);
+        // The type of DYNAMIC_PARAM is indeterminate, so the cast cannot be eliminated
+        if (operand.getKind() != SqlKind.DYNAMIC_PARAM
+                && sameTypeOrNarrowsNullability(e.getType(), operand.getType())
+                // DECIMAL casts are never no-ops: they perform bounds checking
+                && e.getType().getSqlTypeName() != SqlTypeName.DECIMAL) {
+            return operand;
+        }
+        if (RexUtil.isLosslessCast(operand)) {
+            // x :: y below means cast(x as y) (which is PostgreSQL-specific cast by the way)
+            // A) Remove lossless casts:
+            // A.1) intExpr :: bigint :: int => intExpr
+            // A.2) char2Expr :: char(5) :: char(2) => char2Expr
+            // B) There are cases when we can't remove two casts, but we could probably remove inner
+            // one
+            // B.1) char2expression :: char(4) :: char(5) -> char2expression :: char(5)
+            // B.2) char2expression :: char(10) :: char(5) -> char2expression :: char(5)
+            // B.3) char2expression :: varchar(10) :: char(5) -> char2expression :: char(5)
+            // B.4) char6expression :: varchar(10) :: char(5) -> char6expression :: char(5)
+            // C) Simplification is not possible:
+            // C.1) char6expression :: char(3) :: char(5) -> must not be changed
+            //      the input is truncated to 3 chars, so we can't use char6expression :: char(5)
+            // C.2) varchar2Expr :: char(5) :: varchar(2) -> must not be changed
+            //      the input have to be padded with spaces (up to 2 chars)
+            // C.3) char2expression :: char(4) :: varchar(5) -> must not be changed
+            //      would not have the padding
+
+            // The approach seems to be:
+            // 1) Ensure inner cast is lossless (see if above)
+            // 2) If operand of the inner cast has the same type as the outer cast,
+            //    remove two casts except C.2 or C.3-like pattern (== inner cast is CHAR)
+            // 3) If outer cast is lossless, remove inner cast (B-like cases)
+
+            // Here we try to remove two casts in one go (A-like cases)
+            RexNode intExpr = ((RexCall) operand).operands.get(0);
+            // intExpr == CHAR detects A.1
+            // operand != CHAR detects C.2
+            if ((intExpr.getType().getSqlTypeName() == SqlTypeName.CHAR
+                            || operand.getType().getSqlTypeName() != SqlTypeName.CHAR)
+                    && sameTypeOrNarrowsNullability(e.getType(), intExpr.getType())) {
+                return intExpr;
+            }
+            // Here we try to remove inner cast (B-like cases)
+            if (RexUtil.isLosslessCast(intExpr.getType(), operand.getType())
+                    && (e.getType().getSqlTypeName() == operand.getType().getSqlTypeName()
+                            || e.getType().getSqlTypeName() == SqlTypeName.CHAR
+                            || operand.getType().getSqlTypeName() != SqlTypeName.CHAR)
+                    && SqlTypeCoercionRule.instance()
+                            .canApplyFrom(
+                                    intExpr.getType().getSqlTypeName(),
+                                    e.getType().getSqlTypeName())) {
+                return rexBuilder.makeCast(e.getParserPosition(), e.getType(), intExpr);
+            }
+        }
+        final boolean safe = e.getKind() == SqlKind.SAFE_CAST;
+        switch (operand.getKind()) {
+            case LITERAL:
+                final RexLiteral literal = (RexLiteral) operand;
+                final Comparable value = literal.getValueAs(Comparable.class);
+                final SqlTypeName typeName = literal.getTypeName();
+
+                // First, try to remove the cast without changing the value.
+                // makeCast and canRemoveCastFromLiteral have the same logic, so we are
+                // sure to be able to remove the cast.
+                if (rexBuilder.canRemoveCastFromLiteral(e.getType(), value, typeName)) {
+                    return rexBuilder.makeCast(e.getParserPosition(), e.getType(), operand);
+                }
+
+                // Next, try to convert the value to a different type,
+                // e.g. CAST('123' as integer)
+                switch (literal.getTypeName()) {
+                    case TIME:
+                        switch (e.getType().getSqlTypeName()) {
+                            case TIMESTAMP:
+                                return e;
+                            default:
+                                break;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                final List<RexNode> reducedValues = new ArrayList<>();
+                final RexNode simplifiedExpr =
+                        e.operandCount() == 2
+                                ? rexBuilder.makeCast(
+                                        e.getParserPosition(),
+                                        e.getType(),
+                                        operand,
+                                        safe,
+                                        safe,
+                                        (RexLiteral) e.getOperands().get(1))
+                                : rexBuilder.makeCast(e.getType(), operand, safe, safe);
+                executor.reduce(rexBuilder, ImmutableList.of(simplifiedExpr), reducedValues);
+                RexNode reducedRexNode = requireNonNull(Iterables.getOnlyElement(reducedValues));
+                if (reducedRexNode.isA(SqlKind.CAST)) {
+                    RexNode reducedOperand = ((RexCall) reducedRexNode).getOperands().get(0);
+                    if (sameTypeOrNarrowsNullability(
+                            reducedRexNode.getType(), reducedOperand.getType())) {
+                        return reducedOperand;
+                    }
+                }
+                return reducedRexNode;
+            default:
+                if (operand == e.getOperands().get(0)) {
+                    return e;
+                } else {
+                    return e.operands.size() > 1
+                            ? rexBuilder.makeCast(
+                                    e.getParserPosition(),
+                                    e.getType(),
+                                    operand,
+                                    safe,
+                                    safe,
+                                    (RexLiteral) e.getOperands().get(1))
+                            : rexBuilder.makeCast(e.getType(), operand, safe, safe);
+                }
+        }
+    }
+
+    /**
+     * Tries to simplify CEIL/FLOOR function on top of CEIL/FLOOR.
+     *
+     * <p>Examples:
+     *
+     * <ul>
+     *   <li>{@code floor(floor($0, flag(hour)), flag(day))} returns {@code floor($0, flag(day))}
+     *   <li>{@code ceil(ceil($0, flag(second)), flag(day))} returns {@code ceil($0, flag(day))}
+     *   <li>{@code floor(floor($0, flag(day)), flag(second))} does not change
+     * </ul>
+     */
+    private RexNode simplifyCeilFloor(RexCall e) {
+        if (e.getOperands().size() != 2) {
+            // Bail out since we only simplify floor <date>
+            return e;
+        }
+        final RexNode operand = simplify(e.getOperands().get(0), UNKNOWN);
+        if (e.getKind() == operand.getKind()) {
+            assert e.getKind() == SqlKind.CEIL || e.getKind() == SqlKind.FLOOR;
+            // CEIL/FLOOR on top of CEIL/FLOOR
+            final RexCall child = (RexCall) operand;
+            if (child.getOperands().size() != 2) {
+                // Bail out since we only simplify ceil/floor <date>
+                return e;
+            }
+            final RexLiteral parentFlag = (RexLiteral) e.operands.get(1);
+            final TimeUnitRange parentFlagValue = (TimeUnitRange) parentFlag.getValue();
+            final RexLiteral childFlag = (RexLiteral) child.operands.get(1);
+            final TimeUnitRange childFlagValue = (TimeUnitRange) childFlag.getValue();
+            if (parentFlagValue != null && childFlagValue != null) {
+                if (canRollUp(parentFlagValue.startUnit, childFlagValue.startUnit)) {
+                    return e.clone(
+                            e.getType(), ImmutableList.of(child.getOperands().get(0), parentFlag));
+                }
+            }
+        }
+        return e.clone(e.getType(), ImmutableList.of(operand, e.getOperands().get(1)));
+    }
+
+    /**
+     * Simplify TRIM function by eliminating nested duplication.
+     *
+     * <p>Examples:
+     *
+     * <ul>
+     *   <li>{@code trim(trim(' aa '))} returns {@code trim(' aa ')}
+     *   <li>{@code trim(BOTH ' ' from trim(BOTH ' ' from ' aa '))} returns {@code trim(BOTH ' '
+     *       from ' aa ')}
+     *   <li>{@code trim(LEADING 'a' from trim(BOTH ' ' from ' aa '))} does not change
+     * </ul>
+     */
+    private RexNode simplifyTrim(RexCall e) {
+        if (e.getOperands().size() != 3) {
+            return e;
+        }
+
+        RexNode trimType = simplify(e.operands.get(0));
+        RexNode trimed = simplify(e.operands.get(1));
+        if (e.getOperands().get(2) instanceof RexCall) {
+            RexCall childNode = (RexCall) e.getOperands().get(2);
+            // only strings with the same trim method and deduplication will be eliminated.
+            if (childNode.getKind() == SqlKind.TRIM
+                    && trimType.equals(simplify(childNode.operands.get(0)))
+                    && trimed.equals(simplify(childNode.operands.get(1)))) {
+                return simplifyTrim(childNode);
+            }
+        }
+
+        ArrayList<RexNode> rexNodes = new ArrayList<>();
+        rexNodes.add(trimType);
+        rexNodes.add(trimed);
+        rexNodes.add(simplify(e.operands.get(2)));
+        RexNode rexNode = rexBuilder.makeCall(e.getType(), e.getOperator(), rexNodes);
+        return rexNode;
+    }
+
+    /** Method that returns whether we can rollup from inner time unit to outer time unit. */
+    private static boolean canRollUp(TimeUnit outer, TimeUnit inner) {
+        // Special handling for QUARTER as it is not in the expected
+        // order in TimeUnit
+        switch (outer) {
+            case YEAR:
+            case MONTH:
+            case DAY:
+            case HOUR:
+            case MINUTE:
+            case SECOND:
+            case MILLISECOND:
+            case MICROSECOND:
+                switch (inner) {
+                    case YEAR:
+                    case QUARTER:
+                    case MONTH:
+                    case DAY:
+                    case HOUR:
+                    case MINUTE:
+                    case SECOND:
+                    case MILLISECOND:
+                    case MICROSECOND:
+                        if (inner == TimeUnit.QUARTER) {
+                            return outer == TimeUnit.YEAR;
+                        }
+                        return outer.ordinal() <= inner.ordinal();
+                    default:
+                        break;
+                }
+                break;
+            case QUARTER:
+                switch (inner) {
+                    case QUARTER:
+                    case MONTH:
+                    case DAY:
+                    case HOUR:
+                    case MINUTE:
+                    case SECOND:
+                    case MILLISECOND:
+                    case MICROSECOND:
+                        return true;
+                    default:
+                        break;
+                }
+                break;
+            default:
+                break;
+        }
+        return false;
+    }
+
+    /**
+     * Simplifies a measure being converted immediately (in the same SELECT clause) back to a value.
+     *
+     * <p>For most expressions {@code e}, simplifies "{@code m2v(v2m(e))}" to "{@code e}". For
+     * example, "{@code SELECT deptno + 1 AS MEASURE m}" is equivalent to "{@code SELECT deptno + 1
+     * AS m}".
+     *
+     * <p>The exception is aggregate functions. "{@code SELECT COUNT(*) + 1 AS MEASURE m}"
+     * simplifies to "{@code SELECT COUNT(*) OVER (ROWS CURRENT ROW) + 1 AS MEASURE m}".
+     *
+     * @param e Call to {@code M2V} to be simplified
+     * @return Simplified call
+     */
+    private RexNode simplifyM2v(RexCall e) {
+        assert e.op.kind == SqlKind.M2V;
+        final RexNode operand = e.getOperands().get(0);
+        switch (operand.getKind()) {
+            case V2M:
+                // M2V(V2M(x))  -->  x
+                return flattenAggregate(((RexCall) operand).operands.get(0));
+            default:
+                return e;
+        }
+    }
+
+    /**
+     * Traverses over an expression, converting aggregate functions into single-row aggregate
+     * functions.
+     */
+    private RexNode flattenAggregate(RexNode e) {
+        return e.accept(
+                new RexShuttle() {
+                    @Override
+                    public RexNode visitCall(RexCall call) {
+                        if (call.op.isAggregator()) {
+                            final RexWindow w =
+                                    rexBuilder.makeWindow(
+                                            ImmutableList.of(),
+                                            ImmutableList.of(),
+                                            RexWindowBounds.CURRENT_ROW,
+                                            RexWindowBounds.CURRENT_ROW,
+                                            true);
+                            return new RexOver(
+                                    call.type,
+                                    (SqlAggFunction) call.op,
+                                    call.operands,
+                                    w,
+                                    false,
+                                    false);
+                        }
+                        return super.visitCall(call);
+                    }
+                });
+    }
+
+    /**
+     * Removes any casts that change nullability but not type.
+     *
+     * <p>For example, {@code CAST(1 = 0 AS BOOLEAN)} becomes {@code 1 = 0}.
+     */
+    public RexNode removeNullabilityCast(RexNode e) {
+        return RexUtil.removeNullabilityCast(rexBuilder.getTypeFactory(), e);
+    }
+
+    private static <C extends Comparable<C>> @Nullable RexNode processRange(
+            RexBuilder rexBuilder,
+            List<RexNode> terms,
+            Map<RexNode, Pair<Range<C>, List<RexNode>>> rangeTerms,
+            RexNode term,
+            RexNode ref,
+            C v0,
+            SqlKind comparison) {
+        Pair<Range<C>, List<RexNode>> p = rangeTerms.get(ref);
+        if (p == null) {
+            rangeTerms.put(ref, Pair.of(range(comparison, v0), ImmutableList.of(term)));
+        } else {
+            // Exists
+            boolean removeUpperBound = false;
+            boolean removeLowerBound = false;
+            Range<C> r = p.left;
+            final RexLiteral trueLiteral = rexBuilder.makeLiteral(true);
+            switch (comparison) {
+                case EQUALS:
+                    if (!r.contains(v0)) {
+                        // Range is empty, not satisfiable
+                        return rexBuilder.makeLiteral(false);
+                    }
+                    rangeTerms.put(ref, Pair.of(Range.singleton(v0), ImmutableList.of(term)));
+                    // remove
+                    for (RexNode e : p.right) {
+                        replaceLast(terms, e, trueLiteral);
+                    }
+                    break;
+                case LESS_THAN:
+                    {
+                        int comparisonResult = 0;
+                        if (r.hasUpperBound()) {
+                            comparisonResult = v0.compareTo(r.upperEndpoint());
+                        }
+                        if (comparisonResult <= 0) {
+                            // 1) No upper bound, or
+                            // 2) We need to open the upper bound, or
+                            // 3) New upper bound is lower than old upper bound
+                            if (r.hasLowerBound()) {
+                                if (v0.compareTo(r.lowerEndpoint()) <= 0) {
+                                    // Range is empty, not satisfiable
+                                    return rexBuilder.makeLiteral(false);
+                                }
+                                // a <= x < b OR a < x < b
+                                r =
+                                        Range.range(
+                                                r.lowerEndpoint(),
+                                                r.lowerBoundType(),
+                                                v0,
+                                                BoundType.OPEN);
+                            } else {
+                                // x < b
+                                r = Range.lessThan(v0);
+                            }
+
+                            if (r.isEmpty()) {
+                                // Range is empty, not satisfiable
+                                return rexBuilder.makeLiteral(false);
+                            }
+
+                            // remove prev upper bound
+                            removeUpperBound = true;
+                        } else {
+                            // Remove this term as it is contained in current upper bound
+                            replaceLast(terms, term, trueLiteral);
+                        }
+                        break;
+                    }
+                case LESS_THAN_OR_EQUAL:
+                    {
+                        int comparisonResult = -1;
+                        if (r.hasUpperBound()) {
+                            comparisonResult = v0.compareTo(r.upperEndpoint());
+                        }
+                        if (comparisonResult < 0) {
+                            // 1) No upper bound, or
+                            // 2) New upper bound is lower than old upper bound
+                            if (r.hasLowerBound()) {
+                                if (v0.compareTo(r.lowerEndpoint()) < 0) {
+                                    // Range is empty, not satisfiable
+                                    return rexBuilder.makeLiteral(false);
+                                }
+                                // a <= x <= b OR a < x <= b
+                                r =
+                                        Range.range(
+                                                r.lowerEndpoint(),
+                                                r.lowerBoundType(),
+                                                v0,
+                                                BoundType.CLOSED);
+                            } else {
+                                // x <= b
+                                r = Range.atMost(v0);
+                            }
+
+                            if (r.isEmpty()) {
+                                // Range is empty, not satisfiable
+                                return rexBuilder.makeLiteral(false);
+                            }
+
+                            // remove prev upper bound
+                            removeUpperBound = true;
+                        } else {
+                            // Remove this term as it is contained in current upper bound
+                            replaceLast(terms, term, trueLiteral);
+                        }
+                        break;
+                    }
+                case GREATER_THAN:
+                    {
+                        int comparisonResult = 0;
+                        if (r.hasLowerBound()) {
+                            comparisonResult = v0.compareTo(r.lowerEndpoint());
+                        }
+                        if (comparisonResult >= 0) {
+                            // 1) No lower bound, or
+                            // 2) We need to open the lower bound, or
+                            // 3) New lower bound is greater than old lower bound
+                            if (r.hasUpperBound()) {
+                                if (v0.compareTo(r.upperEndpoint()) >= 0) {
+                                    // Range is empty, not satisfiable
+                                    return rexBuilder.makeLiteral(false);
+                                }
+                                // a < x <= b OR a < x < b
+                                r =
+                                        Range.range(
+                                                v0,
+                                                BoundType.OPEN,
+                                                r.upperEndpoint(),
+                                                r.upperBoundType());
+                            } else {
+                                // x > a
+                                r = Range.greaterThan(v0);
+                            }
+
+                            if (r.isEmpty()) {
+                                // Range is empty, not satisfiable
+                                return rexBuilder.makeLiteral(false);
+                            }
+
+                            // remove prev lower bound
+                            removeLowerBound = true;
+                        } else {
+                            // Remove this term as it is contained in current lower bound
+                            replaceLast(terms, term, trueLiteral);
+                        }
+                        break;
+                    }
+                case GREATER_THAN_OR_EQUAL:
+                    {
+                        int comparisonResult = 1;
+                        if (r.hasLowerBound()) {
+                            comparisonResult = v0.compareTo(r.lowerEndpoint());
+                        }
+                        if (comparisonResult > 0) {
+                            // 1) No lower bound, or
+                            // 2) New lower bound is greater than old lower bound
+                            if (r.hasUpperBound()) {
+                                if (v0.compareTo(r.upperEndpoint()) > 0) {
+                                    // Range is empty, not satisfiable
+                                    return rexBuilder.makeLiteral(false);
+                                }
+                                // a <= x <= b OR a <= x < b
+                                r =
+                                        Range.range(
+                                                v0,
+                                                BoundType.CLOSED,
+                                                r.upperEndpoint(),
+                                                r.upperBoundType());
+                            } else {
+                                // x >= a
+                                r = Range.atLeast(v0);
+                            }
+
+                            if (r.isEmpty()) {
+                                // Range is empty, not satisfiable
+                                return rexBuilder.makeLiteral(false);
+                            }
+
+                            // remove prev lower bound
+                            removeLowerBound = true;
+                        } else {
+                            // Remove this term as it is contained in current lower bound
+                            replaceLast(terms, term, trueLiteral);
+                        }
+                        break;
+                    }
+                default:
+                    throw new AssertionError();
+            }
+            if (removeUpperBound) {
+                ImmutableList.Builder<RexNode> newBounds = ImmutableList.builder();
+                for (RexNode e : p.right) {
+                    if (isUpperBound(e)) {
+                        replaceLast(terms, e, trueLiteral);
+                    } else {
+                        newBounds.add(e);
+                    }
+                }
+                newBounds.add(term);
+                rangeTerms.put(ref, Pair.of(r, newBounds.build()));
+            } else if (removeLowerBound) {
+                ImmutableList.Builder<RexNode> newBounds = ImmutableList.builder();
+                for (RexNode e : p.right) {
+                    if (isLowerBound(e)) {
+                        replaceLast(terms, e, trueLiteral);
+                    } else {
+                        newBounds.add(e);
+                    }
+                }
+                newBounds.add(term);
+                rangeTerms.put(ref, Pair.of(r, newBounds.build()));
+            }
+        }
+        // Default
+        return null;
+    }
+
+    private static <C extends Comparable<C>> Range<C> range(SqlKind comparison, C c) {
+        switch (comparison) {
+            case EQUALS:
+                return Range.singleton(c);
+            case LESS_THAN:
+                return Range.lessThan(c);
+            case LESS_THAN_OR_EQUAL:
+                return Range.atMost(c);
+            case GREATER_THAN:
+                return Range.greaterThan(c);
+            case GREATER_THAN_OR_EQUAL:
+                return Range.atLeast(c);
+            default:
+                throw new AssertionError();
+        }
+    }
+
+    private static <C extends Comparable<C>> RangeSet<C> rangeSet(SqlKind comparison, C c) {
+        switch (comparison) {
+            case EQUALS:
+            case LESS_THAN:
+            case LESS_THAN_OR_EQUAL:
+            case GREATER_THAN:
+            case GREATER_THAN_OR_EQUAL:
+                return ImmutableRangeSet.of(range(comparison, c));
+            case NOT_EQUALS:
+                return ImmutableRangeSet.<C>builder()
+                        .add(range(SqlKind.LESS_THAN, c))
+                        .add(range(SqlKind.GREATER_THAN, c))
+                        .build();
+            default:
+                throw new AssertionError();
+        }
+    }
+
+    /** Marker interface for predicates (expressions that evaluate to BOOLEAN). */
+    private interface Predicate {
+        /** Wraps an expression in a Predicate or returns null. */
+        static @Nullable Predicate of(RexNode t) {
+            final Predicate p = Comparison.of(t);
+            if (p != null) {
+                return p;
+            }
+            return IsPredicate.of(t);
+        }
+
+        /** Returns whether this predicate can be used while simplifying other OR operands. */
+        default boolean allowedInOr(RelOptPredicateList predicates) {
+            return true;
+        }
+    }
+
+    /** Visitor which finds all inputs used by an expressions. */
+    private static class VariableCollector extends RexVisitorImpl<Void> {
+        private final Set<RexInputRef> refs = new HashSet<>();
+
+        VariableCollector() {
+            super(true);
+        }
+
+        @Override
+        public Void visitInputRef(RexInputRef inputRef) {
+            refs.add(inputRef);
+            return super.visitInputRef(inputRef);
+        }
+    }
+
+    /**
+     * Represents a simple Comparison.
+     *
+     * <p>Left hand side is a {@link RexNode}, right hand side is a literal.
+     */
+    private static class Comparison implements Predicate {
+        final RexNode ref;
+        final SqlKind kind;
+        final RexLiteral literal;
+
+        private Comparison(RexNode ref, SqlKind kind, RexLiteral literal) {
+            this.ref = requireNonNull(ref, "ref");
+            this.kind = requireNonNull(kind, "kind");
+            this.literal = requireNonNull(literal, "literal");
+        }
+
+        /**
+         * Creates a comparison, between a {@link RexInputRef} or {@link RexFieldAccess} or
+         * deterministic {@link RexCall} and a literal.
+         */
+        static @Nullable Comparison of(RexNode e) {
+            return of(
+                    e,
+                    node ->
+                            RexUtil.isReferenceOrAccess(node, true)
+                                    || RexUtil.isDeterministic(node));
+        }
+
+        /** Creates a comparison, or returns null. */
+        static @Nullable Comparison of(
+                RexNode e, java.util.function.Predicate<RexNode> nodePredicate) {
+            switch (e.getKind()) {
+                case EQUALS:
+                case NOT_EQUALS:
+                case LESS_THAN:
+                case GREATER_THAN:
+                case LESS_THAN_OR_EQUAL:
+                case GREATER_THAN_OR_EQUAL:
+                    final RexCall call = (RexCall) e;
+                    final RexNode left = call.getOperands().get(0);
+                    final RexNode right = call.getOperands().get(1);
+                    switch (right.getKind()) {
+                        case LITERAL:
+                            if (nodePredicate.test(left)) {
+                                return new Comparison(left, e.getKind(), (RexLiteral) right);
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                    switch (left.getKind()) {
+                        case LITERAL:
+                            if (nodePredicate.test(right)) {
+                                return new Comparison(
+                                        right, e.getKind().reverse(), (RexLiteral) left);
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+                default:
+                    break;
+            }
+            return null;
+        }
+
+        @Override
+        public boolean allowedInOr(RelOptPredicateList predicates) {
+            // if ref is not a 'loss-less' cast then can't be allowed to be used
+            // while simplifying other OR operands
+            if (ref.isA(SqlKind.CAST) && !RexUtil.isLosslessCast(ref)) {
+                return false;
+            }
+            return !ref.getType().isNullable() || predicates.isEffectivelyNotNull(ref);
+        }
+    }
+
+    /** Represents an IS Predicate. */
+    private static class IsPredicate implements Predicate {
+        final RexNode ref;
+        final SqlKind kind;
+
+        private IsPredicate(RexNode ref, SqlKind kind) {
+            this.ref = requireNonNull(ref, "ref");
+            this.kind = requireNonNull(kind, "kind");
+        }
+
+        /** Creates an IS predicate, or returns null. */
+        static @Nullable IsPredicate of(RexNode e) {
+            switch (e.getKind()) {
+                case IS_NULL:
+                case IS_NOT_NULL:
+                    RexNode pA = ((RexCall) e).getOperands().get(0);
+                    if (!(RexUtil.isReferenceOrAccess(pA, true) || RexUtil.isDeterministic(pA))) {
+                        return null;
+                    }
+                    return new IsPredicate(pA, e.getKind());
+                default:
+                    break;
+            }
+            return null;
+        }
+    }
+
+    private static boolean isUpperBound(final RexNode e) {
+        final List<RexNode> operands;
+        switch (e.getKind()) {
+            case LESS_THAN:
+            case LESS_THAN_OR_EQUAL:
+                operands = ((RexCall) e).getOperands();
+                return RexUtil.isReferenceOrAccess(operands.get(0), true)
+                        && operands.get(1).isA(SqlKind.LITERAL);
+            case GREATER_THAN:
+            case GREATER_THAN_OR_EQUAL:
+                operands = ((RexCall) e).getOperands();
+                return RexUtil.isReferenceOrAccess(operands.get(1), true)
+                        && operands.get(0).isA(SqlKind.LITERAL);
+            default:
+                return false;
+        }
+    }
+
+    private static boolean isLowerBound(final RexNode e) {
+        final List<RexNode> operands;
+        switch (e.getKind()) {
+            case LESS_THAN:
+            case LESS_THAN_OR_EQUAL:
+                operands = ((RexCall) e).getOperands();
+                return RexUtil.isReferenceOrAccess(operands.get(1), true)
+                        && operands.get(0).isA(SqlKind.LITERAL);
+            case GREATER_THAN:
+            case GREATER_THAN_OR_EQUAL:
+                operands = ((RexCall) e).getOperands();
+                return RexUtil.isReferenceOrAccess(operands.get(0), true)
+                        && operands.get(1).isA(SqlKind.LITERAL);
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Combines predicates AND, optimizes, and returns null if the result is always false.
+     *
+     * <p>The expression is simplified on the assumption that an UNKNOWN value is always treated as
+     * FALSE. Therefore the simplified expression may sometimes evaluate to FALSE where the original
+     * expression would evaluate to UNKNOWN.
+     *
+     * @param predicates Filter condition predicates
+     * @return simplified conjunction of predicates for the filter, null if always false
+     */
+    public @Nullable RexNode simplifyFilterPredicates(Iterable<? extends RexNode> predicates) {
+        final RexNode simplifiedAnds =
+                withPredicateElimination(Bug.CALCITE_2401_FIXED)
+                        .simplifyUnknownAsFalse(RexUtil.composeConjunction(rexBuilder, predicates));
+        if (simplifiedAnds.isAlwaysFalse()) {
+            return null;
+        }
+
+        // Remove cast of BOOLEAN NOT NULL to BOOLEAN or vice versa. Filter accepts
+        // nullable and not-nullable conditions, but a CAST might get in the way of
+        // other rewrites.
+        return removeNullabilityCast(simplifiedAnds);
+    }
+
+    /**
+     * Replaces the last occurrence of one specified value in a list with another.
+     *
+     * <p>Does not change the size of the list.
+     *
+     * <p>Returns whether the value was found.
+     */
+    private static <E> boolean replaceLast(List<E> list, E oldVal, E newVal) {
+        @SuppressWarnings("argument.type.incompatible")
+        final int index = list.lastIndexOf(oldVal);
+        if (index < 0) {
+            return false;
+        }
+        list.set(index, newVal);
+        return true;
+    }
+
+    /** Gathers expressions that can be converted into {@link Sarg search arguments}. */
+    static class SargCollector {
+        final Map<RexNode, RexSargBuilder> map = new HashMap<>();
+        private final RexBuilder rexBuilder;
+        private final boolean negate;
+
+        /**
+         * Count of the new terms after converting all the operands to {@code SEARCH} on a {@link
+         * Sarg}. It is used to decide whether the new terms are simpler.
+         */
+        private int newTermsCount;
+
+        SargCollector(RexBuilder rexBuilder, boolean negate) {
+            this.rexBuilder = rexBuilder;
+            this.negate = negate;
+        }
+
+        /**
+         * Accepts an expression and converts it to a Sarg if possible.
+         *
+         * @param term the expression to convert
+         * @param newTerms the list holding the result of the conversion or the original term if it
+         *     cannot be converted
+         */
+        private void accept(RexNode term, List<RexNode> newTerms) {
+            if (!accept_(term, newTerms)) {
+                newTerms.add(term);
+            }
+            newTermsCount = newTerms.size();
+        }
+
+        /**
+         * Accepts an expression and converts it to a Sarg if possible. Only certain kinds of
+         * expressions can be converted to Sargs.
+         *
+         * @param e the expression to convert
+         * @param newTerms the list to which the Sarg will be added if the expression is accepted
+         * @return true if the expression can be converted to a Sarg, false otherwise
+         */
+        private boolean accept_(RexNode e, List<RexNode> newTerms) {
+            switch (e.getKind()) {
+                case LESS_THAN:
+                case LESS_THAN_OR_EQUAL:
+                case GREATER_THAN:
+                case GREATER_THAN_OR_EQUAL:
+                case EQUALS:
+                case NOT_EQUALS:
+                case SEARCH:
+                case IS_NOT_DISTINCT_FROM:
+                case IS_DISTINCT_FROM:
+                    return accept2(
+                            ((RexCall) e).operands.get(0),
+                            ((RexCall) e).operands.get(1),
+                            e.getKind(),
+                            newTerms);
+                case IS_NULL:
+                case IS_NOT_NULL:
+                    final RexNode arg = ((RexCall) e).operands.get(0);
+                    return accept1(arg, e.getKind(), newTerms);
+                default:
+                    return false;
+            }
+        }
+
+        /**
+         * Accepts two operands from a binary comparison operator and converts them to a Sarg if
+         * possible. Only comparisons between a literal and a deterministic expression can be
+         * converted. Simplifications with non-deterministic expressions are generally avoided to
+         * ensure consistent results.
+         *
+         * @param left the left operand of the comparison
+         * @param right the right operand of the comparison
+         * @param kind the kind of comparison operator
+         * @param newTerms the list to which the Sarg will be added if accepted
+         * @return true if the operands can be converted to a Sarg, false otherwise
+         */
+        private boolean accept2(RexNode left, RexNode right, SqlKind kind, List<RexNode> newTerms) {
+            if (right.isA(SqlKind.LITERAL) && RexUtil.isDeterministic(left)) {
+                return accept2b(left, kind, (RexLiteral) right, newTerms);
+            }
+            if (left.isA(SqlKind.LITERAL) && RexUtil.isDeterministic(right)) {
+                return accept2b(right, kind.reverse(), (RexLiteral) left, newTerms);
+            }
+            return false;
+        }
+
+        private static <E> E addFluent(List<? super E> list, E e) {
+            list.add(e);
+            return e;
+        }
+
+        /**
+         * Accepts an operand from a null predicate and converts it to a Sarg.
+         *
+         * @param e the operand of the null predicate
+         * @param kind the kind of the null predicate
+         * @param newTerms the list to which the Sarg is added
+         * @return true since the operand is always converted to a Sarg
+         */
+        private boolean accept1(RexNode e, SqlKind kind, List<RexNode> newTerms) {
+            final RexSargBuilder b =
+                    map.computeIfAbsent(
+                            e,
+                            e2 -> addFluent(newTerms, new RexSargBuilder(e2, rexBuilder, negate)));
+            switch (negate ? kind.negate() : kind) {
+                case IS_NULL:
+                    b.nullAs = b.nullAs.or(TRUE);
+                    return true;
+                case IS_NOT_NULL:
+                    b.nullAs = b.nullAs.or(FALSE);
+                    b.addAll();
+                    return true;
+                default:
+                    throw new AssertionError("unexpected " + kind);
+            }
+        }
+
+        /**
+         * Accepts two operands from a binary comparison operator and converts them to a Sarg when
+         * the literal is not null. The conversion depends on the kind of comparison operator and
+         * only certain operators are supported.
+         *
+         * @param e any kind of deterministic expression
+         * @param kind the kind of comparison operator
+         * @param literal the literal operand of the comparison
+         * @param newTerms the list to which the Sarg is added if accepted
+         * @return false if the literal operand is null, true otherwise
+         */
+        private boolean accept2b(
+                RexNode e, SqlKind kind, RexLiteral literal, List<RexNode> newTerms) {
+            if (literal.getValue() == null) {
+                // Cannot include expressions 'x > NULL' in a Sarg. Comparing to a NULL
+                // literal is a daft thing to do, because it always returns UNKNOWN. It
+                // is better handled by other simplifications.
+                return false;
+            }
+            final RexSargBuilder b =
+                    map.computeIfAbsent(
+                            e,
+                            e2 -> addFluent(newTerms, new RexSargBuilder(e2, rexBuilder, negate)));
+            if (negate) {
+                kind = kind.negateNullSafe();
+            }
+            final Comparable value = requireNonNull(literal.getValueAs(Comparable.class), "value");
+            switch (kind) {
+                case LESS_THAN:
+                    b.addRange(Range.lessThan(value), literal.getType());
+                    return true;
+                case LESS_THAN_OR_EQUAL:
+                    b.addRange(Range.atMost(value), literal.getType());
+                    return true;
+                case GREATER_THAN:
+                    b.addRange(Range.greaterThan(value), literal.getType());
+                    return true;
+                case GREATER_THAN_OR_EQUAL:
+                    b.addRange(Range.atLeast(value), literal.getType());
+                    return true;
+                case EQUALS:
+                    b.addRange(Range.singleton(value), literal.getType());
+                    return true;
+                case IS_NOT_DISTINCT_FROM:
+                    b.addRange(Range.singleton(value), literal.getType(), FALSE);
+                    return true;
+                case NOT_EQUALS:
+                    b.addRange(Range.lessThan(value), literal.getType());
+                    b.addRange(Range.greaterThan(value), literal.getType());
+                    return true;
+                case IS_DISTINCT_FROM:
+                    b.addRange(Range.lessThan(value), literal.getType(), TRUE);
+                    b.addRange(Range.greaterThan(value), literal.getType(), TRUE);
+                    return true;
+                case SEARCH:
+                    final Sarg sarg = (Sarg) value;
+                    b.addSarg(sarg, negate, literal.getType());
+                    return true;
+                default:
+                    throw new AssertionError("unexpected " + kind);
+            }
+        }
+
+        /** Returns whether it is worth to fix and convert to {@code SEARCH} calls. */
+        boolean needToFix() {
+            // Fix and converts to SEARCH if:
+            // 1. A Sarg has complexity greater than 1;
+            // 2. A Sarg was merged with another Sarg or range;
+            // 3. The terms are reduced as simpler Sarg points;
+            // 4. The terms are reduced as simpler Sarg comparison.
+
+            // Ignore 'negate' just to be compatible with previous versions of this
+            // method. "build().complexity()" would be a better estimate, if we could
+            // switch to it breaking lots of plans.
+            final Collection<RexSargBuilder> builders = map.values();
+            return builders.stream().anyMatch(b -> b.build(false).complexity() > 1 || b.mergedSarg)
+                    || newTermsCount == 1 && builders.stream().allMatch(b -> simpleSarg(b.build()));
+        }
+
+        /**
+         * Returns whether this Sarg can be expanded to more simple form, e.g. the IN call or single
+         * comparison.
+         */
+        private static boolean simpleSarg(Sarg sarg) {
+            return sarg.isPoints()
+                    || RangeSets.isOpenInterval(sarg.rangeSet)
+                    || sarg.isComplementedPoints();
+        }
+
+        /**
+         * If a term is a call to {@code SEARCH} on a {@link RexSargBuilder}, converts it to a
+         * {@code SEARCH} on a {@link Sarg}.
+         */
+        static RexNode fix(RexBuilder rexBuilder, RexNode term, RexUnknownAs unknownAs) {
+            if (term instanceof RexSargBuilder) {
+                final RexSargBuilder sargBuilder = (RexSargBuilder) term;
+                final Sarg sarg = sargBuilder.build();
+                boolean isSmall = sarg.complexity() <= 1 || sarg.isAll() || sarg.isNone();
+                if (isSmall && simpleSarg(sarg)) {
+                    // Expand small sargs into comparisons in order to avoid plan changes
+                    // and better readability.
+                    return RexUtil.sargRef(
+                            rexBuilder, sargBuilder.ref, sarg, term.getType(), unknownAs);
+                }
+                return rexBuilder.makeCall(
+                        SqlStdOperatorTable.SEARCH,
+                        sargBuilder.ref,
+                        rexBuilder.makeSearchArgumentLiteral(sarg, term.getType()));
+            }
+            return term;
+        }
+    }
+
+    /**
+     * Equivalent to a {@link RexLiteral} whose value is a {@link Sarg}, but mutable, so that the
+     * Sarg can be expanded as {@link SargCollector} traverses a list of OR or AND terms.
+     *
+     * <p>The {@link SargCollector#fix} method converts it to an immutable literal.
+     *
+     * <p>The {@link #nullAs} field will become {@link Sarg#nullAs}, as follows:
+     *
+     * <ul>
+     *   <li>If there is at least one term that returns TRUE when the argument is NULL, then the
+     *       overall value will be TRUE; failing that,
+     *   <li>if there is at least one term that returns UNKNOWN when the argument is NULL, then the
+     *       overall value will be UNKNOWN; failing that,
+     *   <li>the value will be FALSE.
+     * </ul>
+     *
+     * <p>This is analogous to the behavior of OR in three-valued logic: {@code TRUE OR UNKNOWN OR
+     * FALSE} returns {@code TRUE}; {@code UNKNOWN OR FALSE OR UNKNOWN} returns {@code UNKNOWN};
+     * {@code FALSE OR FALSE} returns {@code FALSE}.
+     */
+    private static class RexSargBuilder extends RexNode {
+        final RexNode ref;
+        final RexBuilder rexBuilder;
+        final boolean negate;
+        final List<RelDataType> types = new ArrayList<>();
+        final RangeSet<Comparable> rangeSet = TreeRangeSet.create();
+        boolean hasSarg;
+        boolean mergedSarg;
+        RexUnknownAs nullAs = FALSE;
+
+        RexSargBuilder(RexNode ref, RexBuilder rexBuilder, boolean negate) {
+            this.ref = requireNonNull(ref, "ref");
+            this.rexBuilder = requireNonNull(rexBuilder, "rexBuilder");
+            this.negate = negate;
+        }
+
+        @Override
+        public String toString() {
+            return "SEARCH("
+                    + ref
+                    + ", "
+                    + (negate ? "NOT " : "")
+                    + rangeSet
+                    + "; NULL AS "
+                    + nullAs
+                    + ")";
+        }
+
+        <C extends Comparable<C>> Sarg<C> build() {
+            return build(negate);
+        }
+
+        @SuppressWarnings({"rawtypes", "unchecked"})
+        <C extends Comparable<C>> Sarg<C> build(boolean negate) {
+            final RangeSet<C> r = (RangeSet) this.rangeSet;
+            if (negate) {
+                return Sarg.of(nullAs.negate(), r.complement());
+            } else {
+                return Sarg.of(nullAs, r);
+            }
+        }
+
+        @Override
+        public RelDataType getType() {
+            if (this.types.isEmpty()) {
+                // Expression is "x IS NULL"
+                return ref.getType();
+            }
+            final List<RelDataType> distinctTypes = Util.distinctList(this.types);
+            return requireNonNull(
+                    rexBuilder.typeFactory.leastRestrictive(distinctTypes),
+                    () -> "Can't find leastRestrictive type among " + distinctTypes);
+        }
+
+        @Override
+        public <R> R accept(RexVisitor<R> visitor) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public <R, P> R accept(RexBiVisitor<R, P> visitor, P arg) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean equals(@Nullable Object obj) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public int hashCode() {
+            throw new UnsupportedOperationException();
+        }
+
+        void addAll() {
+            rangeSet.add(Range.all());
+        }
+
+        void addRange(Range<Comparable> range, RelDataType type) {
+            addRange(range, type, UNKNOWN);
+        }
+
+        void addRange(Range<Comparable> range, RelDataType type, RexUnknownAs unknownAs) {
+            types.add(type);
+            rangeSet.add(range);
+            mergedSarg |= hasSarg;
+            nullAs = nullAs.or(unknownAs);
+        }
+
+        @SuppressWarnings({"rawtypes", "unchecked"})
+        void addSarg(Sarg sarg, boolean negate, RelDataType type) {
+            final RangeSet r;
+            final RexUnknownAs nullAs;
+            if (negate) {
+                r = sarg.rangeSet.complement();
+                nullAs = sarg.nullAs.negate();
+            } else {
+                r = sarg.rangeSet;
+                nullAs = sarg.nullAs;
+            }
+            types.add(type);
+            rangeSet.addAll(r);
+            mergedSarg |= !rangeSet.isEmpty();
+            hasSarg = true;
+            switch (nullAs) {
+                case TRUE:
+                    this.nullAs = this.nullAs.or(TRUE);
+                    break;
+                case FALSE:
+                    this.nullAs = this.nullAs.or(FALSE);
+                    break;
+                case UNKNOWN:
+                    this.nullAs = this.nullAs.or(UNKNOWN);
+                    break;
+            }
+        }
+    }
+}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
index 65e905b367472..fb9d701c18229 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/rex/RexUtil.java
@@ -25,12 +25,15 @@
 import com.google.common.collect.Range;
 import org.apache.calcite.DataContexts;
 import org.apache.calcite.linq4j.function.Predicate1;
+import org.apache.calcite.plan.PlanTooComplexError;
 import org.apache.calcite.plan.RelOptPredicateList;
 import org.apache.calcite.plan.RelOptUtil;
 import org.apache.calcite.rel.RelCollation;
 import org.apache.calcite.rel.RelCollations;
 import org.apache.calcite.rel.RelFieldCollation;
+import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.core.Calc;
+import org.apache.calcite.rel.core.CorrelationId;
 import org.apache.calcite.rel.core.Filter;
 import org.apache.calcite.rel.core.Join;
 import org.apache.calcite.rel.core.Project;
@@ -805,6 +808,11 @@ public Boolean visitLambda(RexLambda lambda) {
         public Boolean visitLambdaRef(RexLambdaRef lambdaRef) {
             return false;
         }
+
+        @Override
+        public Boolean visitNodeAndFieldIndex(RexNodeAndFieldIndex nodeAndFieldIndex) {
+            return false;
+        }
     }
 
     /**
@@ -844,13 +852,13 @@ public Void visitCall(RexCall call) {
     }
 
     public static List<RexNode> retainDeterministic(List<RexNode> list) {
-        List<RexNode> conjuctions = new ArrayList<>();
+        List<RexNode> conjunctions = new ArrayList<>();
         for (RexNode x : list) {
             if (isDeterministic(x)) {
-                conjuctions.add(x);
+                conjunctions.add(x);
             }
         }
-        return conjuctions;
+        return conjunctions;
     }
 
     /**
@@ -1659,22 +1667,31 @@ public static boolean isLosslessCast(RexNode node) {
      * @return 'true' when the conversion can certainly be determined to be loss-less cast, but may
      *     return 'false' for some lossless casts.
      */
-    @API(since = "1.22", status = API.Status.EXPERIMENTAL)
+    @API(since = "1.22", status = API.Status.STABLE)
     public static boolean isLosslessCast(RelDataType source, RelDataType target) {
         final SqlTypeName sourceSqlTypeName = source.getSqlTypeName();
         final SqlTypeName targetSqlTypeName = target.getSqlTypeName();
-        // 1) Both INT numeric types
-        if (SqlTypeFamily.INTEGER.getTypeNames().contains(sourceSqlTypeName)
-                && SqlTypeFamily.INTEGER.getTypeNames().contains(targetSqlTypeName)) {
-            return targetSqlTypeName.compareTo(sourceSqlTypeName) >= 0;
+
+        // INT -> INT: use range containment (signed/unsigned)
+        if (SqlTypeUtil.isIntType(source) && SqlTypeUtil.isIntType(target)) {
+            final boolean sourceIsUnsigned =
+                    SqlTypeFamily.UNSIGNED_NUMERIC.getTypeNames().contains(sourceSqlTypeName);
+            final boolean targetIsUnsigned =
+                    SqlTypeFamily.UNSIGNED_NUMERIC.getTypeNames().contains(targetSqlTypeName);
+            if (!sourceIsUnsigned && targetIsUnsigned) {
+                return false;
+            }
+            return SqlTypeUtil.integerRangeContains(target, source);
         }
-        // 2) Both CHARACTER types: it depends on the precision (length)
+
+        // CHARACTER -> CHARACTER: valid if target order >= source and length grows
         if (SqlTypeFamily.CHARACTER.getTypeNames().contains(sourceSqlTypeName)
                 && SqlTypeFamily.CHARACTER.getTypeNames().contains(targetSqlTypeName)) {
             return targetSqlTypeName.compareTo(sourceSqlTypeName) >= 0
                     && source.getPrecision() <= target.getPrecision();
         }
-        // 3) From NUMERIC family to CHARACTER family: it depends on the precision/scale
+
+        // NUMERIC -> CHARACTER: allow when target length accommodates sign/scale
         if (sourceSqlTypeName.getFamily() == SqlTypeFamily.NUMERIC
                 && targetSqlTypeName.getFamily() == SqlTypeFamily.CHARACTER) {
             int sourceLength = source.getPrecision() + 1; // include sign
@@ -1684,7 +1701,66 @@ public static boolean isLosslessCast(RelDataType source, RelDataType target) {
             final int targetPrecision = target.getPrecision();
             return targetPrecision == PRECISION_NOT_SPECIFIED || targetPrecision >= sourceLength;
         }
-        // Return FALSE by default
+
+        // DECIMAL -> DECIMAL: allow when precision/scale can only expand
+        if (sourceSqlTypeName == SqlTypeName.DECIMAL && targetSqlTypeName == SqlTypeName.DECIMAL) {
+            int sourcePrecision = source.getPrecision();
+            int sourceScale = Math.max(source.getScale(), 0);
+            int targetPrecision = target.getPrecision();
+            int targetScale = Math.max(target.getScale(), 0);
+            if (sourcePrecision <= 0 || targetPrecision <= 0) {
+                return false;
+            }
+            return targetScale >= sourceScale
+                    && (targetPrecision - targetScale) >= (sourcePrecision - sourceScale);
+        }
+
+        // INT (signed/unsigned) -> DECIMAL: valid if integer digits fit within target precision
+        if (SqlTypeUtil.isIntType(source) && targetSqlTypeName == SqlTypeName.DECIMAL) {
+            int targetPrecision = target.getPrecision();
+            int targetScale = Math.max(target.getScale(), 0);
+            int sourcePrecision = source.getPrecision();
+            return sourcePrecision > 0 && (targetPrecision - targetScale) >= sourcePrecision;
+        }
+
+        // DECIMAL -> INT: only when scale = 0 and range fits target integer type
+        if (sourceSqlTypeName == SqlTypeName.DECIMAL && SqlTypeUtil.isIntType(target)) {
+            if (source.getScale() != 0) {
+                return false;
+            }
+            return SqlTypeUtil.integerRangeContains(target, source);
+        }
+
+        // APPROXIMATE NUMERIC -> APPROXIMATE NUMERIC: allow when target precision >= source
+        // precision
+        if (SqlTypeFamily.APPROXIMATE_NUMERIC.getTypeNames().contains(sourceSqlTypeName)
+                && SqlTypeFamily.APPROXIMATE_NUMERIC.getTypeNames().contains(targetSqlTypeName)) {
+            // Lossless if target has at least as many significant digits as source
+            final int sourcePrecision = source.getPrecision();
+            final int targetPrecision = target.getPrecision();
+            return targetPrecision >= sourcePrecision;
+        }
+
+        // EXACT NUMERIC -> APPROXIMATE NUMERIC: allow only for scale=0 values within target digits
+        if (SqlTypeFamily.EXACT_NUMERIC.getTypeNames().contains(sourceSqlTypeName)
+                && SqlTypeFamily.APPROXIMATE_NUMERIC.getTypeNames().contains(targetSqlTypeName)) {
+            final int targetPrecision = target.getPrecision();
+
+            // DECIMAL -> APPROXIMATE NUMERIC
+            if (sourceSqlTypeName == SqlTypeName.DECIMAL) {
+                final int sourcePrecision = source.getPrecision();
+                if (sourcePrecision <= 0 || source.getScale() != 0) {
+                    return false;
+                }
+                // scale is 0, just check precision
+                return sourcePrecision <= targetPrecision;
+            }
+
+            // INT (signed/unsigned) -> APPROXIMATE NUMERIC
+            int sourcePrecision = source.getPrecision();
+            return sourcePrecision > 0 && sourcePrecision <= targetPrecision;
+        }
+
         return false;
     }
 
@@ -1865,6 +1941,36 @@ public RexNode visitInputRef(RexInputRef input) {
                 });
     }
 
+    /**
+     * Shifts every {@link RexFieldAccess} with {@link CorrelationId} in an {@link RelNode} by
+     * {@code offset}.
+     */
+    public static RelNode shiftFieldAccess(
+            RexBuilder rexBuilder,
+            RelNode node,
+            final CorrelationId id,
+            RelNode outer,
+            final int offset) {
+        if (offset == 0) {
+            return node;
+        }
+
+        RexNode correl = rexBuilder.makeCorrel(outer.getRowType(), id);
+        return node.accept(
+                new RexShuttle() {
+                    @Override
+                    public RexNode visitFieldAccess(RexFieldAccess fieldAccess) {
+                        if (fieldAccess.getReferenceExpr() instanceof RexCorrelVariable
+                                && ((RexCorrelVariable) fieldAccess.getReferenceExpr())
+                                        .id.equals(id)) {
+                            return rexBuilder.makeFieldAccess(
+                                    correl, fieldAccess.getField().getIndex() + offset);
+                        }
+                        return fieldAccess;
+                    }
+                });
+    }
+
     /**
      * Creates an equivalent version of a node where common factors among ORs are pulled up.
      *
@@ -2984,12 +3090,6 @@ public RexNode visitInputRef(RexInputRef input) {
         }
     }
 
-    /**
-     * Exception to catch when optimizing the plan produces a result that is too complex, either at
-     * the Rel or at the Rex level.
-     */
-    private static class PlanTooComplexError extends ControlFlowException {}
-
     /**
      * Visitor that throws {@link org.apache.calcite.util.Util.FoundOne} if applied to an expression
      * that contains a {@link RexCorrelVariable}.
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
index e5a41b36323ca..781331b9b817a 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
@@ -42,6 +42,7 @@
 import org.apache.calcite.linq4j.function.NonDeterministic;
 import org.apache.calcite.linq4j.function.Predicate1;
 import org.apache.calcite.linq4j.tree.Primitive;
+import org.apache.calcite.linq4j.tree.UnsignedType;
 import org.apache.calcite.rel.type.TimeFrame;
 import org.apache.calcite.rel.type.TimeFrameSet;
 import org.apache.calcite.runtime.FlatLists.ComparableList;
@@ -65,10 +66,15 @@
 import org.apache.commons.codec.binary.Hex;
 import org.apache.commons.codec.digest.DigestUtils;
 import org.apache.commons.codec.language.Soundex;
-import org.apache.commons.lang3.StringEscapeUtils;
 import org.apache.commons.math3.util.CombinatoricsUtils;
+import org.apache.commons.text.StringEscapeUtils;
 import org.apache.commons.text.similarity.LevenshteinDistance;
 import org.checkerframework.checker.nullness.qual.Nullable;
+import org.joou.UByte;
+import org.joou.UInteger;
+import org.joou.ULong;
+import org.joou.UShort;
+import org.joou.Unsigned;
 
 import java.lang.reflect.Field;
 import java.math.BigDecimal;
@@ -2530,6 +2536,22 @@ public static Object plusAny(Object b0, Object b1) {
         throw notArithmetic("+", b0, b1);
     }
 
+    public static UByte plus(UByte b0, UByte b1) {
+        return (b0 == null || b1 == null) ? castNonNull(null) : b0.add(b1);
+    }
+
+    public static UShort plus(UShort b0, UShort b1) {
+        return (b0 == null || b1 == null) ? castNonNull(null) : b0.add(b1);
+    }
+
+    public static UInteger plus(UInteger b0, UInteger b1) {
+        return (b0 == null || b1 == null) ? castNonNull(null) : b0.add(b1);
+    }
+
+    public static ULong plus(ULong b0, ULong b1) {
+        return (b0 == null || b1 == null) ? castNonNull(null) : b0.add(b1);
+    }
+
     // checked +
 
     static byte intToByte(int value) {
@@ -2564,6 +2586,22 @@ public static long checkedPlus(long b0, long b1) {
         return Math.addExact(b0, b1);
     }
 
+    public static UByte checkedPlus(UByte b0, UByte b1) {
+        return b0.add(b1);
+    }
+
+    public static UShort checkedPlus(UShort b0, UShort b1) {
+        return b0.add(b1);
+    }
+
+    public static UInteger checkedPlus(UInteger b0, UInteger b1) {
+        return b0.add(b1);
+    }
+
+    public static ULong checkedPlus(ULong b0, ULong b1) {
+        return b0.add(b1);
+    }
+
     // -
 
     /** SQL <code>-</code> operator applied to int values. */
@@ -2596,6 +2634,11 @@ public static Long minus(Integer b0, Long b1) {
         return (b0 == null || b1 == null) ? castNonNull(null) : (b0.longValue() - b1.longValue());
     }
 
+    /** SQL <code>-</code> operator applied to nullable long and long values. */
+    public static Long minus(Long b0, Long b1) {
+        return (b0 == null || b1 == null) ? castNonNull(null) : b0.longValue() - b1.longValue();
+    }
+
     /** SQL <code>-</code> operator applied to nullable BigDecimal values. */
     public static BigDecimal minus(BigDecimal b0, BigDecimal b1) {
         return (b0 == null || b1 == null) ? castNonNull(null) : b0.subtract(b1);
@@ -2617,6 +2660,23 @@ public static Object minusAny(Object b0, Object b1) {
         throw notArithmetic("-", b0, b1);
     }
 
+    public static UByte minus(UByte b0, UByte b1) {
+        return (b0 == null || b1 == null) ? castNonNull(null) : b0.subtract(b1);
+    }
+
+    public static UShort minus(UShort b0, UShort b1) {
+        return (b0 == null || b1 == null) ? castNonNull(null) : b0.subtract(b1);
+    }
+
+    public static UInteger minus(UInteger b0, UInteger b1) {
+        return (b0 == null || b1 == null) ? castNonNull(null) : b0.subtract(b1);
+    }
+
+    /** SQL <code>-</code> operator applied to nullable unsigned long and long values. */
+    public static ULong minus(ULong b0, ULong b1) {
+        return (b0 == null || b1 == null) ? castNonNull(null) : b0.subtract(b1);
+    }
+
     // checked -
 
     public static byte checkedMinus(byte b0, byte b1) {
@@ -2651,6 +2711,38 @@ public static long checkedUnaryMinus(long b) {
         return Math.subtractExact(0, b);
     }
 
+    public static UByte checkedMinus(UByte b0, UByte b1) {
+        return b0.subtract(b1);
+    }
+
+    public static UShort checkedMinus(UShort b0, UShort b1) {
+        return b0.subtract(b1);
+    }
+
+    public static UInteger checkedMinus(UInteger b0, UInteger b1) {
+        return b0.subtract(b1);
+    }
+
+    public static ULong checkedMinus(ULong b0, ULong b1) {
+        return b0.subtract(b1);
+    }
+
+    public static UByte checkedUnaryMinus(UByte b) {
+        return Unsigned.ubyte(0).subtract(b);
+    }
+
+    public static UShort checkedUnaryMinus(UShort b) {
+        return Unsigned.ushort(0).subtract(b);
+    }
+
+    public static UInteger checkedUnaryMinus(UInteger b) {
+        return Unsigned.uint(0).subtract(b);
+    }
+
+    public static ULong checkedUnaryMinus(ULong b) {
+        return Unsigned.ulong(0).subtract(b);
+    }
+
     // /
 
     /** SQL <code>/</code> operator applied to int values. */
@@ -2714,6 +2806,31 @@ public static long divide(long b0, BigDecimal b1) {
         return BigDecimal.valueOf(b0).divide(b1, RoundingMode.HALF_DOWN).longValue();
     }
 
+    public static UByte divide(UByte b0, UByte b1) {
+        return (b0 == null || b1 == null)
+                ? castNonNull(null)
+                : UByte.valueOf(b0.intValue() / b1.intValue());
+    }
+
+    public static UShort divide(UShort b0, UShort b1) {
+        return (b0 == null || b1 == null)
+                ? castNonNull(null)
+                : UShort.valueOf(b0.intValue() / b1.intValue());
+    }
+
+    public static UInteger divide(UInteger b0, UInteger b1) {
+        return (b0 == null || b1 == null)
+                ? castNonNull(null)
+                : UInteger.valueOf(b0.longValue() / b1.longValue());
+    }
+
+    public static ULong divide(ULong b0, ULong b1) {
+        return (b0 == null || b1 == null)
+                ? castNonNull(null)
+                : ULong.valueOf(
+                        UnsignedType.toBigInteger(b0).divide(UnsignedType.toBigInteger(b1)));
+    }
+
     public static byte checkedDivide(byte b0, byte b1) {
         return intToByte(b0 / b1);
     }
@@ -2742,6 +2859,22 @@ public static long checkedDivide(long b0, long b1) {
         }
     }
 
+    public static UByte checkedDivide(UByte b0, UByte b1) {
+        return UByte.valueOf(b0.intValue() / b1.intValue());
+    }
+
+    public static UShort checkedDivide(UShort b0, UShort b1) {
+        return UShort.valueOf(b0.intValue() / b1.intValue());
+    }
+
+    public static UInteger checkedDivide(UInteger b0, UInteger b1) {
+        return UInteger.valueOf(b0.longValue() / b1.longValue());
+    }
+
+    public static ULong checkedDivide(ULong b0, ULong b1) {
+        return ULong.valueOf(UnsignedType.toBigInteger(b0).divide(UnsignedType.toBigInteger(b1)));
+    }
+
     // *
 
     /** SQL <code>*</code> operator applied to int values. */
@@ -2764,6 +2897,32 @@ public static Integer multiply(Integer b0, Integer b1) {
         return (b0 == null || b1 == null) ? castNonNull(null) : (b0 * b1);
     }
 
+    public static UByte multiply(UByte b0, UByte b1) {
+        return (b0 == null || b1 == null)
+                ? castNonNull(null)
+                : UByte.valueOf(b0.longValue() * b1.longValue());
+    }
+
+    public static UShort multiply(UShort b0, UShort b1) {
+        return (b0 == null || b1 == null)
+                ? castNonNull(null)
+                : UShort.valueOf(b0.intValue() * b1.intValue());
+    }
+
+    public static UInteger multiply(UInteger b0, UInteger b1) {
+        return (b0 == null || b1 == null)
+                ? castNonNull(null)
+                : UInteger.valueOf(b0.longValue() * b1.longValue());
+    }
+
+    public static ULong multiply(ULong b0, ULong b1) {
+        if (b0 == null || b1 == null) {
+            return castNonNull(null);
+        }
+        BigInteger result = UnsignedType.toBigInteger(b0).multiply(UnsignedType.toBigInteger(b1));
+        return ULong.valueOf(result);
+    }
+
     /** SQL <code>*</code> operator applied to nullable long and int values. */
     public static Long multiply(Long b0, Integer b1) {
         return (b0 == null || b1 == null) ? castNonNull(null) : (b0.longValue() * b1.longValue());
@@ -2813,6 +2972,22 @@ public static long checkedMultiply(long b0, long b1) {
         return Math.multiplyExact(b0, b1);
     }
 
+    public static UByte checkedMultiply(UByte b0, UByte b1) {
+        return UByte.valueOf(b0.intValue() * b1.intValue());
+    }
+
+    public static UShort checkedMultiply(UShort b0, UShort b1) {
+        return UShort.valueOf(b0.intValue() * b1.intValue());
+    }
+
+    public static UInteger checkedMultiply(UInteger b0, UInteger b1) {
+        return UInteger.valueOf(b0.longValue() * b1.longValue());
+    }
+
+    public static ULong checkedMultiply(ULong b0, ULong b1) {
+        return ULong.valueOf(UnsignedType.toBigInteger(b0).multiply(UnsignedType.toBigInteger(b1)));
+    }
+
     /** SQL <code>SAFE_ADD</code> function applied to long values. */
     public static @Nullable Long safeAdd(long b0, long b1) {
         try {
@@ -3105,6 +3280,126 @@ public static ByteString bitAnd(ByteString b0, ByteString b1) {
         return binaryOperator(b0, b1, (x, y) -> (byte) (x & y));
     }
 
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.UByte} values. Returns {@code
+     * null} if any operand is null.
+     */
+    public static UByte bitAnd(UByte b0, UByte b1) {
+        return UByte.valueOf((short) (b0.shortValue() & b1.shortValue()));
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.UShort} values. Returns
+     * {@code null} if any operand is null.
+     */
+    public static UShort bitAnd(UShort b0, UShort b1) {
+        return UShort.valueOf(b0.intValue() & b1.intValue());
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.UInteger} values. Returns
+     * {@code null} if any operand is null.
+     */
+    public static UInteger bitAnd(UInteger b0, UInteger b1) {
+        return UInteger.valueOf(b0.longValue() & b1.longValue());
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.ULong} values. Returns {@code
+     * null} if any operand is null.
+     */
+    public static ULong bitAnd(ULong b0, ULong b1) {
+        return ULong.valueOf(b0.longValue() & b1.longValue());
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.UInteger} and {@link Integer}
+     * values. Returns {@code null} if any operand is null.
+     */
+    public static long bitAnd(UInteger b0, long b1) {
+        return b0.intValue() & b1;
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.ULong} and {@link long}
+     * values. Returns {@code null} if any operand is null.
+     */
+    public static long bitAnd(ULong b0, long b1) {
+        return b0.longValue() & b1;
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link long} and {@link org.joou.UInteger}
+     * values. Returns {@code null} if any operand is null.
+     */
+    public static long bitAnd(long b1, ULong b2) {
+        return b1 & b2.longValue();
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link long} and {@link org.joou.UInteger}
+     * values. Returns {@code null} if any operand is null.
+     */
+    public static long bitAnd(long b1, UInteger b2) {
+        return b1 & b2.longValue();
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.UShort} and {@link Integer}
+     * values. Returns {@code null} if any operand is null.
+     */
+    public static long bitAnd(UShort b0, long b1) {
+        return b0.intValue() & b1;
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.UShort} and {@link Integer}
+     * values. Returns {@code null} if any operand is null.
+     */
+    public static long bitAnd(long b0, UShort b1) {
+        return b0 & b1.intValue();
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.UInteger} and {@link Integer}
+     * values. Returns {@code null} if any operand is null.
+     */
+    public static UInteger bitAnd(UInteger b0, int b1) {
+        return UInteger.valueOf(b0.intValue() & b1);
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.UInteger} and {@link Integer}
+     * values. Returns {@code null} if any operand is null.
+     */
+    public static ULong bitAnd(ULong b0, int b1) {
+        return ULong.valueOf(b0.longValue() & b1);
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link Integer} and {@link org.joou.UInteger}
+     * values. Returns {@code null} if any operand is null.
+     */
+    public static ULong bitAnd(int b1, ULong b2) {
+        return ULong.valueOf(b1 & b2.longValue());
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.UShort} and {@link Integer}
+     * values. Returns {@code null} if any operand is null.
+     */
+    public static Integer bitAnd(int b0, UShort b1) {
+        return b0 & b1.intValue();
+    }
+
+    /**
+     * Bitwise function <code>BITAND</code> applied to {@link org.joou.UShort} and {@link Integer}
+     * values. Returns {@code null} if any operand is null.
+     */
+    public static Integer bitAnd(UShort b0, int b1) {
+        return b0.intValue() & b1;
+    }
+
     /**
      * Helper function for implementing <code>BITCOUNT</code>. Counts the number of bits set in an
      * integer value.
@@ -3232,16 +3527,16 @@ public static long bitXor(long b0, long b1) {
     }
 
     /**
-     * Bitwise function <code>BITXOR</code> applied to a Long and int value. Needed for handling
-     * NULL for the first argument.
+     * Bitwise function <code>BITXOR</code> applied to a Long and int value. Overload to support
+     * type coercion between boxed Long and primitive int.
      */
     public static long bitXor(Long b0, int b1) {
         return b0 ^ b1;
     }
 
     /**
-     * Bitwise function <code>BITXOR</code> applied to a Long and int value. Needed for handling
-     * NULL for the second argument.
+     * Bitwise function <code>BITXOR</code> applied to a Long and int value. Overload to support
+     * type coercion between boxed Long and primitive int.
      */
     public static long bitXor(int b0, Long b1) {
         return b0 ^ b1;
@@ -3267,6 +3562,62 @@ public static ByteString bitNot(ByteString b) {
         return new ByteString(result);
     }
 
+    /**
+     * Bitwise function <code>BITXOR</code> applied to {@link Long} values. Returns {@code null} if
+     * any operand is null.
+     */
+    public static long bitXor(Long b0, Long b1) {
+        return b0 ^ b1;
+    }
+
+    /**
+     * Bitwise function <code>BITXOR</code> applied to {@link Integer} values. Returns {@code null}
+     * if any operand is null.
+     */
+    public static long bitXor(Integer b0, Integer b1) {
+        return b0 ^ b1;
+    }
+
+    /**
+     * Bitwise function <code>BITXOR</code> applied to {@link org.joou.UByte} values. Returns {@code
+     * null} if any operand is null.
+     */
+    public static UByte bitXor(UByte b0, UByte b1) {
+        return UByte.valueOf(b0.shortValue() ^ b1.shortValue());
+    }
+
+    /**
+     * Bitwise function <code>BITXOR</code> applied to {@link org.joou.UShort} values. Returns
+     * {@code null} if any operand is null.
+     */
+    public static UShort bitXor(UShort b0, UShort b1) {
+        return UShort.valueOf(b0.intValue() ^ b1.intValue());
+    }
+
+    /**
+     * Bitwise function <code>BITXOR</code> applied to {@link org.joou.UInteger} values. Returns
+     * {@code null} if any operand is null.
+     */
+    public static UInteger bitXor(UInteger b0, UInteger b1) {
+        return UInteger.valueOf(b0.longValue() ^ b1.longValue());
+    }
+
+    /**
+     * Bitwise function <code>BITXOR</code> applied to {@link org.joou.ULong} values. Returns {@code
+     * null} if any operand is null.
+     */
+    public static ULong bitXor(ULong b0, ULong b1) {
+        return ULong.valueOf(b0.longValue() ^ b1.longValue());
+    }
+
+    public static @Nullable Object bitXor(@Nullable Object b0, @Nullable Object b1) {
+        if (b0 == null || b1 == null) {
+            return null;
+        }
+        throw new IllegalArgumentException(
+                "Invalid arguments for BITXOR: " + "" + b0.getClass() + ", " + b1.getClass());
+    }
+
     /**
      * Utility for bitwise function applied to two byteString values.
      *
@@ -3296,6 +3647,139 @@ private static ByteString binaryOperator(
         return new ByteString(result);
     }
 
+    /**
+     * Performs PostgresSQL-style bitwise shift on a 32-bit integer.
+     *
+     * @param x the integer value to shift
+     * @param y the shift amount (positive: left shift, negative: right shift)
+     * @return the shifted integer
+     */
+    public static int leftShift(int x, int y) {
+        int shift = ((y % 32) + 32) % 32; // normalize to 0~31
+        return y >= 0 ? x << shift : x >> shift; // arithmetic right shift
+    }
+
+    // ----------------- long -----------------
+    /**
+     * Performs PostgresSQL-style bitwise shift on a 64-bit long value.
+     *
+     * @param x the long value to shift
+     * @param y the shift amount
+     * @return the shifted long value
+     */
+    public static long leftShift(long x, int y) {
+        int shift = ((y % 64) + 64) % 64; // normalize to 0~63
+        return y >= 0 ? x << shift : x >> shift;
+    }
+
+    /**
+     * Performs PostgresSQL-style bitwise shift on an int value with a long shift amount.
+     *
+     * @param x the int value to shift
+     * @param y the long shift amount
+     * @return the shifted value as long
+     */
+    public static long leftShift(int x, long y) {
+        int shift = (int) (((y % 32) + 32) % 32); // normalize to 0~31
+        return y >= 0 ? (long) x << shift : (long) x >> shift;
+    }
+
+    /**
+     * Performs PostgresSQL-style bitwise shift on a byte array. Positive shift: left shift.
+     * Negative shift: treated as positive shift with modulo arithmetic.
+     *
+     * @param bytes the input byte array
+     * @param y the shift amount in bits
+     * @return the shifted byte array
+     */
+    public static byte[] leftShift(byte[] bytes, int y) {
+        if (bytes.length == 0) {
+            return new byte[0];
+        }
+
+        int bitLen = bytes.length * 8;
+
+        // PostgreSQL behavior: always treat as left shift with modulo arithmetic
+        // Negative y becomes equivalent positive shift
+        int shift = ((y % bitLen) + bitLen) % bitLen;
+
+        if (shift == 0) {
+            return bytes.clone();
+        }
+
+        byte[] result = new byte[bytes.length];
+
+        // Always perform left shift (even for originally negative y)
+        int byteShift = shift / 8;
+        int bitShift = shift % 8;
+
+        for (int i = 0; i < bytes.length; i++) {
+            int srcIndex = i - byteShift;
+            int val = 0;
+
+            // Get the main byte
+            if (srcIndex >= 0) {
+                val = (bytes[srcIndex] & 0xFF) << bitShift;
+            }
+
+            // Get carry bits from previous byte
+            if (srcIndex - 1 >= 0 && bitShift != 0) {
+                val |= (bytes[srcIndex - 1] & 0xFF) >>> (8 - bitShift);
+            }
+
+            result[i] = (byte) val;
+        }
+        return result;
+    }
+
+    /**
+     * Performs PostgresSQL-style bitwise shift on ByteString.
+     *
+     * @param bytes the ByteString to shift
+     * @param y the shift amount in bits
+     * @return shifted ByteString
+     */
+    public static ByteString leftShift(ByteString bytes, int y) {
+        return new ByteString(leftShift(bytes.getBytes(), y));
+    }
+
+    /** Performs PostgresSQL-style bitwise shift on UByte. Overflow bits are masked to 8 bits. */
+    public static UByte leftShift(UByte x, int y) {
+        int shift = ((y % 8) + 8) % 8;
+        int val = x.byteValue() & 0xFF;
+        val = (y >= 0) ? (val << shift) & 0xFF : (val >> shift) & 0xFF;
+        return UByte.valueOf((byte) val);
+    }
+
+    /** Performs PostgresSQL-style bitwise shift on UShort. Overflow bits are masked to 16 bits. */
+    public static UShort leftShift(UShort x, int y) {
+        int shift = ((y % 16) + 16) % 16;
+        int val = x.shortValue() & 0xFFFF;
+        val = (y >= 0) ? (val << shift) & 0xFFFF : (val >> shift) & 0xFFFF;
+        return UShort.valueOf((short) val);
+    }
+
+    /**
+     * Performs PostgresSQL-style bitwise shift on UInteger. Overflow bits are masked to 32 bits.
+     */
+    public static UInteger leftShift(UInteger x, int y) {
+        int shift = ((y % 32) + 32) % 32;
+        long val = x.longValue() & 0xFFFFFFFFL;
+        val = (y >= 0) ? (val << shift) & 0xFFFFFFFFL : (val >> shift) & 0xFFFFFFFFL;
+        return UInteger.valueOf(val);
+    }
+
+    /**
+     * Performs PostgresSQL-style bitwise shift on ULong. Overflow bits are masked to 64 bits (long
+     * shifts naturally truncate).
+     */
+    public static ULong leftShift(ULong x, int y) {
+        int shift = ((y % 64) + 64) % 64;
+        long val = x.longValue();
+        val = (y >= 0) ? val << shift : val >> shift;
+        return ULong.valueOf(val);
+    }
+
     // EXP
 
     /** SQL <code>EXP</code> operator applied to double values. */
@@ -5870,7 +6354,7 @@ public static String replace(
             return s.replace(search, replacement);
         }
         // for MSSQL's REPLACE function, search pattern is case-insensitive during matching
-        return org.apache.commons.lang3.StringUtils.replaceIgnoreCase(s, search, replacement);
+        return org.apache.commons.lang3.Strings.CI.replace(s, search, replacement);
     }
 
     /**
@@ -6667,12 +7151,12 @@ public static String arrayToString(List list, String delimiter, @Nullable String
      * array by splitting the input string value into subvalues using the specified string value as
      * the "delimiter". Optionally, allows a specified string value to be interpreted as NULL.
      */
-    public static List<String> stringToArray(String string, @Nullable String delimiter) {
+    public static List<@Nullable String> stringToArray(String string, @Nullable String delimiter) {
         return stringToArray(string, delimiter, null);
     }
 
     /** SQL {@code STRING_TO_ARRAY(string, delimiter, nullString)} function. */
-    public static List<String> stringToArray(
+    public static List<@Nullable String> stringToArray(
             String string, @Nullable String delimiter, @Nullable String nullString) {
         String[] parts;
         if (delimiter == null) {
@@ -6685,7 +7169,7 @@ public static List<String> stringToArray(
         } else {
             parts = string.split(delimiter);
         }
-        List<String> result = new ArrayList<>(parts.length);
+        List<@Nullable String> result = new ArrayList<>(parts.length);
         for (String part : parts) {
             if (nullString != null && nullString.equals(part)) {
                 result.add(null);
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/fun/SqlCoalesceFunction.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/fun/SqlCoalesceFunction.java
index 556a0c2abd2bf..da666184d9e76 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/fun/SqlCoalesceFunction.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/fun/SqlCoalesceFunction.java
@@ -123,11 +123,10 @@ public RelDataType inferReturnType(SqlOperatorBinding opBinding) {
         }
 
         if (returnType == null) {
-            throw new IllegalArgumentException(
-                    "Cannot infer return type for "
-                            + opBinding.getOperator()
-                            + "; operand types: "
-                            + opBinding.collectOperandTypes());
+            throw opBinding.newError(
+                    RESOURCE.cannotInferReturnType(
+                            opBinding.getOperator().toString(),
+                            opBinding.collectOperandTypes().toString()));
         }
 
         return returnType;
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
index 6e564abe68e47..eb8bbaff448ea 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
@@ -329,6 +329,8 @@ private static void assertBasic(SqlTypeName typeName) {
                                         ? createSqlType(typeName, type.getPrecision())
                                         : createSqlType(typeName);
                 type = createTypeWithNullability(type, originalType.isNullable());
+                // update java type's family
+                family = type.getFamily();
             }
 
             if (resultType == null) {
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
index 2aa111e918a81..bab7f620637ff 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
@@ -42,6 +42,7 @@
 import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.sql.validate.SqlValidatorScope;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
+import org.apache.calcite.sql2rel.SqlToRelConverter;
 import org.apache.calcite.util.NumberUtil;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
@@ -50,6 +51,7 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.math.RoundingMode;
 import java.nio.charset.Charset;
 import java.util.AbstractList;
@@ -120,6 +122,40 @@ public static boolean isCharTypeComparable(List<RelDataType> argTypes) {
         return true;
     }
 
+    /**
+     * True if there are literals with the specified data type. Some data types do not have literals
+     * (e.g., UNSIGNED, ROW).
+     *
+     * @param type Type for literals.
+     */
+    public static boolean hasLiterals(RelDataType type) {
+        switch (type.getSqlTypeName()) {
+            case UTINYINT:
+            case USMALLINT:
+            case UINTEGER:
+            case UBIGINT:
+            case ANY:
+            case SYMBOL:
+            case MULTISET:
+            case ARRAY:
+            case MAP:
+            case DISTINCT:
+            case STRUCTURED:
+            case ROW:
+            case OTHER:
+            case CURSOR:
+            case COLUMN_LIST:
+            case DYNAMIC_STAR:
+            case GEOMETRY:
+            case MEASURE:
+            case FUNCTION:
+            case SARG:
+                return false;
+            default:
+                return true;
+        }
+    }
+
     /**
      * Returns whether the operands to a call are char type-comparable.
      *
@@ -145,12 +181,58 @@ public static boolean isCharTypeComparable(
         return true;
     }
 
+    /**
+     * A namespace may contain multiple fields with the same name. However, a proper ROW type
+     * cannot; this function will assign unique names to fields when they are used to build a
+     * concrete ROW type.
+     *
+     * @param type A type for which type.isStruct() is true.
+     * @return A new version of this type where all fields have unique names.
+     *     <p>Note: the same rule to rename fields is used by the {@link SqlToRelConverter} later,
+     *     in convertNonAggregateSelectList (a private method). This ensures that the generated
+     *     field names there will match with the inferred field names here.
+     */
+    private static RelDataType uniquify(RelDataTypeFactory factory, RelDataType type) {
+        List<String> unique = SqlValidatorUtil.uniquify(type.getFieldNames(), true);
+        List<RelDataType> types =
+                type.getFieldList().stream()
+                        .map(RelDataTypeField::getType)
+                        .collect(Collectors.toList());
+        return factory.createStructType(type.getStructKind(), types, unique);
+    }
+
+    /**
+     * Derives component type for ARRAY, MULTISET, MAP when input is sub-query.
+     *
+     * @param factory Type factory used to generate new types if necessary
+     * @param origin original component type
+     * @return component type
+     */
+    public static RelDataType deriveCollectionQueryComponentType(
+            RelDataTypeFactory factory, SqlTypeName collectionType, RelDataType origin) {
+        switch (collectionType) {
+            case ARRAY:
+            case MULTISET:
+                return origin.isStruct() && origin.getFieldCount() == 1
+                        ? origin.getFieldList().get(0).getType()
+                        : uniquify(factory, origin);
+            case MAP:
+                return origin;
+            default:
+                throw new AssertionError(
+                        "Impossible to derive component type for " + collectionType);
+        }
+    }
+
     /**
      * Derives component type for ARRAY, MULTISET, MAP when input is sub-query.
      *
      * @param origin original component type
      * @return component type
+     * @deprecated Use {@link SqlTypeUtil#deriveCollectionQueryComponentType(RelDataTypeFactory,
+     *     SqlTypeName, RelDataType)}
      */
+    @Deprecated
     public static RelDataType deriveCollectionQueryComponentType(
             SqlTypeName collectionType, RelDataType origin) {
         switch (collectionType) {
@@ -464,6 +546,10 @@ public static boolean isIntType(RelDataType type) {
             case SMALLINT:
             case INTEGER:
             case BIGINT:
+            case UTINYINT:
+            case USMALLINT:
+            case UINTEGER:
+            case UBIGINT:
                 return true;
             default:
                 return false;
@@ -490,6 +576,10 @@ public static boolean isExactNumeric(RelDataType type) {
             case SMALLINT:
             case INTEGER:
             case BIGINT:
+            case UTINYINT:
+            case USMALLINT:
+            case UINTEGER:
+            case UBIGINT:
             case DECIMAL:
                 return true;
             default:
@@ -497,12 +587,88 @@ public static boolean isExactNumeric(RelDataType type) {
         }
     }
 
+    /**
+     * Returns whether {@code container} can represent every value produced by {@code content}
+     * without loss of information.
+     *
+     * <p>The {@code container} type must be one of the integer types (signed or unsigned). The
+     * {@code content} type can be integer, or a DECIMAL with scale {@code 0}. For all other types
+     * this method returns {@code false}.
+     *
+     * @throws IllegalArgumentException if {@code container} is not an integer type
+     */
+    public static boolean integerRangeContains(RelDataType container, RelDataType content) {
+        checkArgument(isIntType(container), "container must be an integer type: %s", container);
+
+        final SqlTypeName contentType = content.getSqlTypeName();
+        final boolean contentIsDecimal = contentType == SqlTypeName.DECIMAL;
+        if (!isIntType(content) && (!contentIsDecimal || content.getScale() != 0)) {
+            return false;
+        }
+
+        final BigInteger containerMin = integerBound(container, false);
+        final BigInteger containerMax = integerBound(container, true);
+        if (containerMin == null || containerMax == null) {
+            return false;
+        }
+
+        final BigInteger contentMin = integerBound(content, false);
+        final BigInteger contentMax = integerBound(content, true);
+        if (contentMin == null || contentMax == null) {
+            return false;
+        }
+
+        return containerMin.compareTo(contentMin) <= 0 && containerMax.compareTo(contentMax) >= 0;
+    }
+
+    /**
+     * Returns the numeric bound for an integer or zero-scale decimal type.
+     *
+     * @param type Type whose bounds should be computed
+     * @param upper If {@code true}, returns the maximum inclusive bound; otherwise returns the
+     *     minimum bound
+     * @return Bound as {@link BigInteger}, or {@code null} if the bound cannot be determined (for
+     *     example, type is not integer or has non-zero scale)
+     */
+    public static @Nullable BigInteger integerBound(RelDataType type, boolean upper) {
+        final SqlTypeName typeName = type.getSqlTypeName();
+
+        final boolean isDecimal = typeName == SqlTypeName.DECIMAL;
+        if (!isDecimal && !isIntType(type)) {
+            return null;
+        }
+        if (isDecimal && type.getScale() != 0) {
+            return null;
+        }
+
+        final int precision = isDecimal ? type.getPrecision() : -1;
+        final int scale = isDecimal ? type.getScale() : -1;
+        final Object limit =
+                typeName.getLimit(upper, SqlTypeName.Limit.OVERFLOW, false, precision, scale);
+        if (limit == null) {
+            return null;
+        }
+        if (limit instanceof BigDecimal) {
+            try {
+                return ((BigDecimal) limit).toBigIntegerExact();
+            } catch (ArithmeticException ignored) {
+                return null;
+            }
+        }
+        if (limit instanceof Number) {
+            return BigInteger.valueOf(((Number) limit).longValue());
+        }
+        return null;
+    }
+
     /** Returns whether a type's scale is set. */
     public static boolean hasScale(RelDataType type) {
         return type.getScale() != Integer.MIN_VALUE;
     }
 
-    /** Returns the maximum value of an integral type, as a long value. */
+    /**
+     * Returns the maximum value of an integral type, as a long value. DOES NOT WORK FOR UBIGINT.
+     */
     public static long maxValue(RelDataType type) {
         assert SqlTypeUtil.isIntType(type);
         switch (type.getSqlTypeName()) {
@@ -512,6 +678,12 @@ public static long maxValue(RelDataType type) {
                 return Short.MAX_VALUE;
             case INTEGER:
                 return Integer.MAX_VALUE;
+            case UTINYINT:
+                return 255;
+            case USMALLINT:
+                return 65535;
+            case UINTEGER:
+                return (1L << 32) - 1;
             case BIGINT:
                 return Long.MAX_VALUE;
             default:
@@ -648,8 +820,9 @@ public static int getMaxByteSize(RelDataType type) {
     /**
      * Returns the minimum unscaled value of a numeric type.
      *
-     * @param type a numeric type
+     * @deprecated Use {@link #integerBound(RelDataType, boolean)} with {@code upper = false}
      */
+    @Deprecated // to be removed before 2.0
     public static long getMinValue(RelDataType type) {
         SqlTypeName typeName = type.getSqlTypeName();
         switch (typeName) {
@@ -659,6 +832,11 @@ public static long getMinValue(RelDataType type) {
                 return Short.MIN_VALUE;
             case INTEGER:
                 return Integer.MIN_VALUE;
+            case UTINYINT:
+            case USMALLINT:
+            case UINTEGER:
+            case UBIGINT:
+                return 0;
             case BIGINT:
             case DECIMAL:
                 return NumberUtil.getMinUnscaled(type.getPrecision()).longValue();
@@ -668,17 +846,25 @@ public static long getMinValue(RelDataType type) {
     }
 
     /**
-     * Returns the maximum unscaled value of a numeric type.
+     * Returns the maximum unscaled value of a numeric type. DOES NOT WORK CORRECTLY FOR U/BIGINT
+     * and many DECIMAL types.
      *
-     * @param type a numeric type
+     * @deprecated Use {@link #integerBound(RelDataType, boolean)} with {@code upper = true}
      */
+    @Deprecated // to be removed before 2.0
     public static long getMaxValue(RelDataType type) {
         SqlTypeName typeName = type.getSqlTypeName();
         switch (typeName) {
+            case UTINYINT:
+                return 255;
             case TINYINT:
                 return Byte.MAX_VALUE;
+            case USMALLINT:
+                return (1 << 16) - 1;
             case SMALLINT:
                 return Short.MAX_VALUE;
+            case UINTEGER:
+                return (1L << 32) - 1;
             case INTEGER:
                 return Integer.MAX_VALUE;
             case BIGINT:
@@ -892,7 +1078,8 @@ public static boolean canCastFrom(
             return true;
         }
         if (toType.getSqlTypeName() == SqlTypeName.UUID) {
-            return fromType.getSqlTypeName() == SqlTypeName.UUID
+            return fromType.getSqlTypeName() == SqlTypeName.NULL
+                    || fromType.getSqlTypeName() == SqlTypeName.UUID
                     || fromType.getFamily() == SqlTypeFamily.CHARACTER
                     || fromType.getFamily() == SqlTypeFamily.BINARY;
         }
@@ -1081,7 +1268,8 @@ public static SqlDataTypeSpec convertTypeToSpec(
         if (isAtomic(type)
                 || isNull(type)
                 || type.getSqlTypeName() == SqlTypeName.UNKNOWN
-                || type.getSqlTypeName() == SqlTypeName.GEOMETRY) {
+                || type.getSqlTypeName() == SqlTypeName.GEOMETRY
+                || SqlTypeUtil.isInterval(type)) {
             int precision =
                     typeName.allowsPrec()
                             ? type.getPrecision()
@@ -1099,9 +1287,11 @@ public static SqlDataTypeSpec convertTypeToSpec(
                     new SqlBasicTypeNameSpec(
                             typeName, precision, scale, charSetName, SqlParserPos.ZERO);
         } else if (isCollection(type)) {
+            RelDataType componentType = getComponentTypeOrThrow(type);
             typeNameSpec =
                     new SqlCollectionTypeNameSpec(
-                            convertTypeToSpec(getComponentTypeOrThrow(type)).getTypeNameSpec(),
+                            convertTypeToSpec(componentType).getTypeNameSpec(),
+                            componentType.isNullable(),
                             typeName,
                             SqlParserPos.ZERO);
         } else if (isRow(type)) {
@@ -1139,9 +1329,7 @@ public static SqlDataTypeSpec convertTypeToSpec(
         // REVIEW angel 11-Jan-2006:
         // Use neg numbers to indicate unspecified precision/scale
 
-        // FLINK MODIFICATION BEGIN
         return new SqlDataTypeSpec(typeNameSpec, SqlParserPos.ZERO).withNullable(type.isNullable());
-        // FLINK MODIFICATION BEGIN
     }
 
     /**
@@ -1458,7 +1646,6 @@ public static boolean isFlat(RelDataType type) {
      * @return Whether types are comparable
      */
     public static boolean isComparable(RelDataType type1, RelDataType type2) {
-        // FLINK MODIFICATION BEGIN Calcite-7230
         final RelDataTypeFamily family1 = family(type1);
         final RelDataTypeFamily family2 = family(type2);
 
@@ -1466,7 +1653,7 @@ public static boolean isComparable(RelDataType type1, RelDataType type2) {
         if (family1 == SqlTypeFamily.NULL || family2 == SqlTypeFamily.NULL) {
             return true;
         }
-        // FLINK MODIFICATION END
+
         if (type1.isStruct() != type2.isStruct()) {
             return false;
         }
@@ -1516,11 +1703,6 @@ public static boolean isComparable(RelDataType type1, RelDataType type2) {
             return true;
         }
 
-        // If one of the arguments is of type 'NULL', return true.
-        if (family1 == SqlTypeFamily.NULL || family2 == SqlTypeFamily.NULL) {
-            return true;
-        }
-
         // We can implicitly convert from character to date
         return family1 == SqlTypeFamily.CHARACTER && canConvertStringInCompare(family2)
                 || family2 == SqlTypeFamily.CHARACTER && canConvertStringInCompare(family1);
@@ -1807,7 +1989,8 @@ public static boolean isAtomic(RelDataType type) {
         return SqlTypeUtil.isDatetime(type)
                 || SqlTypeUtil.isNumeric(type)
                 || SqlTypeUtil.isString(type)
-                || SqlTypeUtil.isBoolean(type);
+                || SqlTypeUtil.isBoolean(type)
+                || typeName == SqlTypeName.UUID;
     }
 
     /** Returns a DECIMAL type with the maximum precision for the current type system. */
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index 640765c51b48d..fa33edc4103e1 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -523,6 +523,15 @@ private boolean expandSelectItem(
             // calls.
             selectScope = getSelectScope(select);
             expanded = expandSelectExpr(selectItem, scope, select, expansions);
+
+            // Non-strict GROUP BY: wrap non-aggregated, non-grouped columns in ANY_VALUE()
+            if (isAggregate(select)
+                    && config.conformance().isNonStrictGroupBy()
+                    && isNonAggregatedNonGroupedColumn(expanded, select)) {
+                expanded =
+                        SqlStdOperatorTable.ANY_VALUE.createCall(
+                                expanded.getParserPosition(), expanded);
+            }
         }
         final String alias = SqlValidatorUtil.alias(selectItem, aliases.size());
 
@@ -560,56 +569,32 @@ private boolean expandSelectItem(
         return false;
     }
 
-    private static SqlNode expandExprFromJoin(
-            SqlJoin join, SqlIdentifier identifier, SelectScope scope) {
-        if (join.getConditionType() != JoinConditionType.USING) {
-            return identifier;
+    /** Returns true if the node is a non-aggregated, non-grouped column in SELECT. */
+    private boolean isNonAggregatedNonGroupedColumn(SqlNode node, SqlSelect select) {
+        if (aggFinder.findAgg(node) != null) {
+            return false;
         }
 
-        final Map<String, String> fieldAliases = getFieldAliases(scope);
-
-        for (String name : SqlIdentifier.simpleNames((SqlNodeList) getCondition(join))) {
-            if (identifier.getSimple().equals(name)) {
-                final List<SqlNode> qualifiedNode = new ArrayList<>();
-                for (ScopeChild child : requireNonNull(scope, "scope").children) {
-                    if (child.namespace.getRowType().getFieldNames().contains(name)) {
-                        final SqlIdentifier exp =
-                                new SqlIdentifier(
-                                        ImmutableList.of(child.name, name),
-                                        identifier.getParserPosition());
-                        qualifiedNode.add(exp);
-                    }
-                }
-
-                assert qualifiedNode.size() == 2;
-
-                // If there is an alias for the column, no need to wrap the coalesce with an AS
-                // operator
-                boolean haveAlias = fieldAliases.containsKey(name);
-
-                final SqlCall coalesceCall =
-                        SqlStdOperatorTable.COALESCE.createCall(
-                                SqlParserPos.ZERO, qualifiedNode.get(0), qualifiedNode.get(1));
-
-                if (haveAlias) {
-                    return coalesceCall;
-                } else {
-                    return SqlStdOperatorTable.AS.createCall(
-                            SqlParserPos.ZERO,
-                            coalesceCall,
-                            new SqlIdentifier(name, SqlParserPos.ZERO));
-                }
+        if (node instanceof SqlIdentifier) {
+            SqlNodeList groupList = select.getGroup();
+            if (groupList == null) {
+                return true;
             }
+            return groupList.getList().stream()
+                    .noneMatch(
+                            groupItem ->
+                                    groupItem != null && node.equalsDeep(groupItem, Litmus.IGNORE));
         }
 
-        // Only need to try to expand the expr from the left input of join
-        // since it is always left-deep join.
-        final SqlNode node = join.getLeft();
-        if (node instanceof SqlJoin) {
-            return expandExprFromJoin((SqlJoin) node, identifier, scope);
-        } else {
-            return identifier;
+        if (node instanceof SqlCall) {
+            return ((SqlCall) node)
+                    .getOperandList().stream()
+                            .anyMatch(operand -> isNonAggregatedNonGroupedColumn(operand, select));
+        } else if (node instanceof SqlLiteral) {
+            return true;
         }
+
+        return false;
     }
 
     private static Map<String, String> getFieldAliases(final SelectScope scope) {
@@ -661,31 +646,6 @@ private List<String> deriveNaturalJoinColumnList(SqlJoin join) {
                 getNamespaceOrThrow(join.getRight()).getRowType());
     }
 
-    private static SqlNode expandCommonColumn(
-            SqlSelect sqlSelect,
-            SqlNode selectItem,
-            SelectScope scope,
-            SqlValidatorImpl validator) {
-        if (!(selectItem instanceof SqlIdentifier)) {
-            return selectItem;
-        }
-
-        final SqlNode from = sqlSelect.getFrom();
-        if (!(from instanceof SqlJoin)) {
-            return selectItem;
-        }
-
-        final SqlIdentifier identifier = (SqlIdentifier) selectItem;
-        if (!identifier.isSimple()) {
-            if (!validator.config().conformance().allowQualifyingCommonColumn()) {
-                validateQualifiedCommonColumn((SqlJoin) from, identifier, scope, validator);
-            }
-            return selectItem;
-        }
-
-        return expandExprFromJoin((SqlJoin) from, identifier, scope);
-    }
-
     private static void validateQualifiedCommonColumn(
             SqlJoin join, SqlIdentifier identifier, SelectScope scope, SqlValidatorImpl validator) {
         List<String> names = validator.usingNames(join);
@@ -1393,9 +1353,7 @@ private SqlValidatorScope getScopeOrThrow(SqlNode node) {
                 }
             // fall through
             case TABLE_REF:
-            // ----- FLINK MODIFICATION BEGIN -----
             case LATERAL:
-            // ----- FLINK MODIFICATION END -----
             case SNAPSHOT:
             case OVER:
             case COLLECTION_TABLE:
@@ -3472,7 +3430,7 @@ public void validateLiteral(SqlLiteral literal) {
                 final BigDecimal noTrailingZeros = bd.stripTrailingZeros();
                 // If we don't strip trailing zeros we may reject values such as 1.000....0.
 
-                final int maxPrecision = typeSystem.getMaxNumericPrecision();
+                final int maxPrecision = typeSystem.getMaxPrecision(SqlTypeName.DECIMAL);
                 if (noTrailingZeros.precision() > maxPrecision) {
                     throw newValidationError(
                             literal, RESOURCE.numberLiteralOutOfRange(bd.toString()));
@@ -3735,6 +3693,24 @@ private void checkRollUpInUsing(
         }
     }
 
+    /**
+     * Get the number of scopes referenced by the specified node; the node represents a computation
+     * that will be converted to a Rel node eventually.
+     */
+    private int getScopeCount(SqlNode node) {
+        SqlValidatorScope scope = scopes.get(node);
+        if (scope == null) {
+            // Not all nodes have an associated scope; count these as "1".
+            // For example, a VALUES node.
+            return 1;
+        }
+        if (scope instanceof ListScope) {
+            ListScope join = (ListScope) scope;
+            return join.children.size();
+        }
+        return 1;
+    }
+
     protected void validateJoin(SqlJoin join, SqlValidatorScope scope) {
         final SqlNode left = join.getLeft();
         final SqlNode right = join.getRight();
@@ -3836,9 +3812,11 @@ protected void validateJoin(SqlJoin join, SqlValidatorScope scope) {
                                 condition, RESOURCE.asofConditionMustBeComparison());
                     }
 
+                    int leftScopeCount = getScopeCount(left);
                     CompareFromBothSides validateCompare =
                             new CompareFromBothSides(
                                     joinScope,
+                                    leftScopeCount,
                                     catalogReader,
                                     RESOURCE.asofConditionMustBeComparison());
                     condition.accept(validateCompare);
@@ -3858,7 +3836,10 @@ protected void validateJoin(SqlJoin join, SqlValidatorScope scope) {
                     // Change the exception in validateCompare when we validate the match condition
                     validateCompare =
                             new CompareFromBothSides(
-                                    joinScope, catalogReader, RESOURCE.asofMatchMustBeComparison());
+                                    joinScope,
+                                    leftScopeCount,
+                                    catalogReader,
+                                    RESOURCE.asofMatchMustBeComparison());
                     matchCondition.accept(validateCompare);
                     break;
                 }
@@ -3874,16 +3855,21 @@ protected void validateJoin(SqlJoin join, SqlValidatorScope scope) {
      */
     private class CompareFromBothSides extends SqlShuttle {
         final SqlValidatorScope scope;
+        // Number of children scopes on the left side of the join.
+        // Used to determine whether an identifier is from the left input or the right input.
+        final int leftScopeCount;
         final SqlValidatorCatalogReader catalogReader;
         final Resources.ExInst<SqlValidatorException> exception;
 
         private CompareFromBothSides(
                 SqlValidatorScope scope,
+                int leftScopeCount,
                 SqlValidatorCatalogReader catalogReader,
                 Resources.ExInst<SqlValidatorException> exception) {
             this.scope = scope;
             this.catalogReader = catalogReader;
             this.exception = exception;
+            this.leftScopeCount = leftScopeCount;
         }
 
         @Override
@@ -3917,16 +3903,11 @@ private CompareFromBothSides(
                             id.names.subList(0, id.names.size() - 1), nameMatcher, false, resolved);
                     SqlValidatorScope.Resolve resolve = resolved.only();
                     int index = resolve.path.steps().get(0).i;
-                    if (index == 0) {
+                    if (index < leftScopeCount) {
                         leftFound = true;
-                    }
-                    if (index == 1) {
+                    } else {
                         rightFound = true;
                     }
-
-                    if (!leftFound && !rightFound) {
-                        throw newValidationError(call, this.exception);
-                    }
                 }
                 if (!leftFound || !rightFound) {
                     // The comparison does not look at both tables
@@ -5686,13 +5667,6 @@ protected void checkTypeAssignment(
         // matched
         boolean isUpdateModifiableViewTable = false;
         if (query instanceof SqlUpdate) {
-            final SqlNodeList targetColumnList =
-                    requireNonNull(((SqlUpdate) query).getTargetColumnList());
-            final int targetColumnCount = targetColumnList.size();
-            targetRowType =
-                    SqlTypeUtil.extractLastNFields(typeFactory, targetRowType, targetColumnCount);
-            sourceRowType =
-                    SqlTypeUtil.extractLastNFields(typeFactory, sourceRowType, targetColumnCount);
             isUpdateModifiableViewTable = table.unwrap(ModifiableViewTable.class) != null;
         }
         if (SqlTypeUtil.equalAsStructSansNullability(
@@ -5813,6 +5787,16 @@ public void validateUpdate(SqlUpdate call) {
         final RelDataType sourceRowType = getValidatedNodeType(select);
         checkTypeAssignment(scopes.get(select), table, sourceRowType, targetRowType, call);
 
+        // Set validated sourceExpressionList from the source select.
+        // The last elements of sourceSelect are the expression list.
+        List<SqlNode> sourceExpressionList =
+                Util.last(select.getSelectList(), call.getSourceExpressionList().size());
+        call.setOperand(
+                2,
+                SqlUtil.stripListAs(
+                        new SqlNodeList(
+                                sourceExpressionList,
+                                call.getSourceExpressionList().getParserPosition())));
         checkConstraint(table, call, targetRowType);
 
         validateAccess(call.getTargetTable(), table, SqlAccessEnum.UPDATE);
@@ -7328,6 +7312,30 @@ public SqlNode go(SqlNode root) {
             return requireNonNull(root.accept(this), () -> this + " returned null for " + root);
         }
 
+        /** True if the exception ex indicates that name lookup has failed. */
+        public static boolean isNotFoundException(Exception ex) {
+            if (!(ex instanceof CalciteContextException)) {
+                return false;
+            }
+            String message = ex.getMessage();
+            if (message == null || !message.contains("not found")) {
+                return false;
+            }
+            return true;
+        }
+
+        /** True if the exception ex indicates that a column is ambiguous. */
+        public static boolean isAmbiguousException(Exception ex) {
+            if (!(ex instanceof CalciteContextException)) {
+                return false;
+            }
+            String message = ex.getMessage();
+            if (message == null || !message.contains("is ambiguous")) {
+                return false;
+            }
+            return true;
+        }
+
         @Override
         public @Nullable SqlNode visit(SqlIdentifier id) {
             // First check for builtin functions which don't have
@@ -7383,6 +7391,88 @@ protected SqlNode expandDynamicStar(SqlIdentifier id, SqlIdentifier fqId) {
             }
             return fqId;
         }
+
+        protected SqlNode expandCommonColumn(
+                SqlSelect sqlSelect, SqlNode selectItem, SelectScope scope) {
+            if (!(selectItem instanceof SqlIdentifier)) {
+                return selectItem;
+            }
+
+            final SqlNode from = sqlSelect.getFrom();
+            if (!(from instanceof SqlJoin)) {
+                return selectItem;
+            }
+
+            final SqlIdentifier identifier = (SqlIdentifier) selectItem;
+            if (!identifier.isSimple()) {
+                if (!validator.config().conformance().allowQualifyingCommonColumn()) {
+                    validateQualifiedCommonColumn((SqlJoin) from, identifier, scope, validator);
+                }
+                return selectItem;
+            }
+
+            return expandExprFromJoin((SqlJoin) from, identifier, scope);
+        }
+
+        private SqlNode expandExprFromJoin(
+                SqlJoin join, SqlIdentifier identifier, SelectScope scope) {
+            List<String> commonColumnNames;
+            // must be NATURAL or USING here, and cannot specify NATURAL keyword with USING clause
+            if (join.isNatural()) {
+                commonColumnNames = validator.deriveNaturalJoinColumnList(join);
+            } else if (join.getConditionType() == JoinConditionType.USING) {
+                commonColumnNames = SqlIdentifier.simpleNames((SqlNodeList) getCondition(join));
+            } else {
+                return identifier;
+            }
+
+            final SqlNameMatcher matcher = validator.getCatalogReader().nameMatcher();
+            final Map<String, String> fieldAliases = getFieldAliases(scope);
+
+            for (String name : commonColumnNames) {
+                if (matcher.matches(identifier.getSimple(), name)) {
+                    final List<SqlNode> qualifiedNode = new ArrayList<>();
+                    for (ScopeChild child : requireNonNull(scope, "scope").children) {
+                        if (matcher.indexOf(child.namespace.getRowType().getFieldNames(), name)
+                                >= 0) {
+                            final SqlIdentifier exp =
+                                    new SqlIdentifier(
+                                            ImmutableList.of(child.name, name),
+                                            identifier.getParserPosition());
+                            qualifiedNode.add(exp);
+                        }
+                    }
+
+                    assert qualifiedNode.size() == 2;
+
+                    // If there is an alias for the column, no need to wrap the coalesce with an AS
+                    // operator
+                    boolean haveAlias = fieldAliases.containsKey(name);
+
+                    final SqlCall coalesceCall =
+                            SqlStdOperatorTable.COALESCE.createCall(
+                                    SqlParserPos.ZERO, qualifiedNode.get(0), qualifiedNode.get(1));
+
+                    if (haveAlias) {
+                        return coalesceCall;
+                    } else {
+                        return SqlStdOperatorTable.AS.createCall(
+                                SqlParserPos.ZERO,
+                                coalesceCall,
+                                new SqlIdentifier(identifier.getSimple(), SqlParserPos.ZERO));
+                    }
+                }
+            }
+
+            // Only need to try to expand the expr from the left input of join
+            // since it is always left-deep join.
+            final SqlNode node = join.getLeft();
+            if (node instanceof SqlJoin) {
+                return expandExprFromJoin((SqlJoin) node, identifier, scope);
+            } else {
+                return identifier;
+            }
+        }
     }
 
     /**
@@ -7545,19 +7635,14 @@ public SqlNode go(SqlNode root) {
 
         @Override
         public @Nullable SqlNode visit(SqlIdentifier id) {
-            final SqlNode node =
-                    expandCommonColumn(select, id, (SelectScope) getScope(), validator);
+            final SqlNode node = expandCommonColumn(select, id, (SelectScope) getScope());
             if (node != id) {
                 return node;
             } else {
                 try {
                     return super.visit(id);
                 } catch (Exception ex) {
-                    if (!(ex instanceof CalciteContextException)) {
-                        throw ex;
-                    }
-                    String message = ex.getMessage();
-                    if (message != null && !message.contains("not found")) {
+                    if (!isNotFoundException(ex)) {
                         throw ex;
                     }
                     // This point is reached only if the name lookup failed using standard rules
@@ -7642,7 +7727,10 @@ static class ExtendedExpander extends Expander {
         final SqlSelect select;
         final SqlNode root;
         final Clause clause;
-        // Retain only expandable aliases or ordinals to prevent their expansion in a SQL call expr.
+        // This contains the ordinal nodes in a GROUP BY that may need to be expanded
+        // into column names when using a conformance that allows ordinals in group bys
+        // E.g., For GROUP BY 1, 1 will be in this list
+        // For GROUP BY CUBE(1), 1 will also be in this list
         final Set<SqlNode> aliasOrdinalExpandSet = Sets.newIdentityHashSet();
 
         ExtendedExpander(
@@ -7656,7 +7744,7 @@ static class ExtendedExpander extends Expander {
             this.root = root;
             this.clause = clause;
             if (clause == Clause.GROUP_BY) {
-                addExpandableExpressions();
+                addExpandableOrdinals();
             }
         }
 
@@ -7668,18 +7756,53 @@ static class ExtendedExpander extends Expander {
 
             final SelectScope selectScope = validator.getRawSelectScopeNonNull(select);
             final boolean replaceAliases = clause.shouldReplaceAliases(validator.config);
-            if (!replaceAliases
-                    || (clause == Clause.GROUP_BY && !aliasOrdinalExpandSet.contains(id))) {
-                SqlNode node = expandCommonColumn(select, id, selectScope, validator);
-                if (node != id) {
-                    return node;
+            try {
+                // First try a standard expansion
+                if (clause == Clause.GROUP_BY) {
+                    SqlNode node = expandCommonColumn(select, id, selectScope);
+                    if (node != id) {
+                        return node;
+                    }
+                    return super.visit(id);
                 }
-                return super.visit(id);
+            } catch (Exception ex) {
+                // This behavior is from MySQL:
+                // - if there is no column in the FROM with the name used in the GROUP BY
+                //   then look for a column alias in the SELECT
+                // - if there are multiple columns in the FROM with the name used in the GROUP BY,
+                //   then also look for a column alias in the SELECT
+                if (!Expander.isNotFoundException(ex) && !Expander.isAmbiguousException(ex)) {
+                    throw ex;
+                }
+                if (!replaceAliases) {
+                    throw ex;
+                }
+                // Continue execution, trying to replace alias
             }
 
+            final SqlNameMatcher nameMatcher = validator.catalogReader.nameMatcher();
+
+            if (clause == Clause.HAVING) {
+                if (!replaceAliases) {
+                    return id;
+                }
+
+                // Do not expand aliases in HAVING if they are being grouped on
+                SqlNodeList list = select.getGroup();
+                if (list != null) {
+                    // HAVING can be used without GROUP BY
+                    for (SqlNode node : list) {
+                        if (node instanceof SqlIdentifier) {
+                            SqlIdentifier grouped = (SqlIdentifier) node;
+                            if (nameMatcher.matches(id.getSimple(), Util.last(grouped.names))) {
+                                return id;
+                            }
+                        }
+                    }
+                }
+            }
             String name = id.getSimple();
             SqlNode expr = null;
-            final SqlNameMatcher nameMatcher = validator.catalogReader.nameMatcher();
             int n = 0;
             for (SqlNode s : SqlNonNullableAccessors.getSelectList(select)) {
                 final @Nullable String alias = SqlValidatorUtil.alias(s);
@@ -7704,8 +7827,10 @@ static class ExtendedExpander extends Expander {
 
             // expr cannot be null; in that case n = 0 would have returned
             requireNonNull(expr, "expr");
-            if (validator.getConformance().isSelectAlias()
-                    != SqlConformance.SelectAliasLookup.UNSUPPORTED) {
+            if ((clause == Clause.SELECT
+                            && (validator.getConformance().isSelectAlias()
+                                    != SqlConformance.SelectAliasLookup.UNSUPPORTED))
+                    || clause == Clause.GROUP_BY) {
                 Map<String, SqlNode> expansions = new HashMap<>();
                 final Expander expander =
                         new SelectExpander(validator, selectScope, select, expansions);
@@ -7751,18 +7876,13 @@ static class ExtendedExpander extends Expander {
                         break;
                 }
             }
-
             return super.visit(literal);
         }
 
-        /**
-         * Add all possible expandable 'group by' expression to set, which is used to check whether
-         * expr could be expanded as alias or ordinal.
-         */
+        /** Add all possible expandable 'group by' ordinals to {@link aliasOrdinalExpandSet}. */
         @RequiresNonNull({"root"})
-        private void addExpandableExpressions() {
+        private void addExpandableOrdinals() {
             switch (root.getKind()) {
-                case IDENTIFIER:
                 case LITERAL:
                     aliasOrdinalExpandSet.add(root);
                     break;
@@ -7772,7 +7892,7 @@ private void addExpandableExpressions() {
                     if (root instanceof SqlBasicCall) {
                         List<SqlNode> operandList = ((SqlBasicCall) root).getOperandList();
                         for (SqlNode sqlNode : operandList) {
-                            addIdentifierOrdinal2ExpandSet(sqlNode);
+                            addOrdinal2ExpandSet(sqlNode);
                         }
                     }
                     break;
@@ -7782,18 +7902,17 @@ private void addExpandableExpressions() {
         }
 
         /**
-         * Identifier or literal in grouping sets, rollup, cube will be eligible for alias.
+         * Literal in grouping sets, rollup, cube will be expanded.
          *
          * @param sqlNode expression within grouping sets, rollup, cube
          */
-        private void addIdentifierOrdinal2ExpandSet(SqlNode sqlNode) {
+        private void addOrdinal2ExpandSet(SqlNode sqlNode) {
             if (sqlNode.getKind() == SqlKind.ROW) {
                 List<SqlNode> rowOperandList = ((SqlCall) sqlNode).getOperandList();
                 for (SqlNode node : rowOperandList) {
-                    addIdentifierOrdinal2ExpandSet(node);
+                    addOrdinal2ExpandSet(node);
                 }
-            } else if (sqlNode.getKind() == SqlKind.IDENTIFIER
-                    || sqlNode.getKind() == SqlKind.LITERAL) {
+            } else if (sqlNode.getKind() == SqlKind.LITERAL) {
                 aliasOrdinalExpandSet.add(sqlNode);
             }
         }
@@ -8361,14 +8480,10 @@ private enum Clause {
         boolean shouldReplaceAliases(Config config) {
             switch (this) {
                 case GROUP_BY:
-                    return config.conformance().isGroupByAlias()
-                            || (config.conformance().isSelectAlias()
-                                    != SqlConformance.SelectAliasLookup.UNSUPPORTED);
+                    return config.conformance().isGroupByAlias();
 
                 case HAVING:
-                    return config.conformance().isHavingAlias()
-                            || (config.conformance().isSelectAlias()
-                                    != SqlConformance.SelectAliasLookup.UNSUPPORTED);
+                    return config.conformance().isHavingAlias();
 
                 case QUALIFY:
                     return true;
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
index d350cc7cca6ef..00661e9392b81 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
@@ -57,7 +57,6 @@
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.core.RelFactories;
 import org.apache.calcite.rel.core.Sort;
-import org.apache.calcite.rel.core.Values;
 import org.apache.calcite.rel.logical.LogicalAggregate;
 import org.apache.calcite.rel.logical.LogicalCorrelate;
 import org.apache.calcite.rel.logical.LogicalFilter;
@@ -112,11 +111,14 @@
 import org.slf4j.Logger;
 
 import java.math.BigDecimal;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Deque;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.NavigableMap;
@@ -153,10 +155,21 @@ public class RelDecorrelator implements ReflectiveVisitor {
     // map built during translation
     protected CorelMap cm;
 
+    /**
+     * Stack maintaining visible Frames to the currently invoked RelNode during top-down traversal.
+     * Each entry maps a CorrelationId to the Frame where its correlated variables originate.
+     */
+    protected final Deque<Pair<CorrelationId, Frame>> frameStack = new ArrayDeque<>();
+
     @SuppressWarnings("method.invocation.invalid")
     protected final ReflectUtil.MethodDispatcher<@Nullable Frame> dispatcher =
             ReflectUtil.<RelNode, @Nullable Frame>createMethodDispatcher(
-                    Frame.class, getVisitor(), "decorrelateRel", RelNode.class, boolean.class);
+                    Frame.class,
+                    getVisitor(),
+                    "decorrelateRel",
+                    RelNode.class,
+                    boolean.class,
+                    boolean.class);
 
     // The rel which is being visited
     protected @Nullable RelNode currentRel;
@@ -355,8 +368,28 @@ protected RelNode decorrelate(RelNode root) {
         // Perform decorrelation.
         map.clear();
 
-        final Frame frame = getInvoke(root, false, null);
+        final Frame frame = getInvoke(root, false, null, true);
         if (frame != null) {
+            // Check if the frame has more fields than the original and discard the extra ones
+            RelNode result = frame.r;
+            int fields = frame.r.getRowType().getFieldCount();
+            if (fields > frame.oldToNewOutputs.size()) {
+                relBuilder.push(result);
+                final List<RexNode> exprList = new ArrayList<>();
+                List<Map.Entry<Integer, Integer>> entries =
+                        new ArrayList<>(frame.oldToNewOutputs.entrySet());
+                entries.sort(Map.Entry.comparingByKey());
+                for (Map.Entry<Integer, Integer> entry : entries) {
+                    exprList.add(relBuilder.field(entry.getValue()));
+                }
+                relBuilder.project(exprList);
+                result = relBuilder.build();
+            } else {
+                Litmus.THROW.check(
+                        fields == frame.oldToNewOutputs.size(),
+                        "Produced relation has fewer columns than the original relation");
+            }
+
             // has been rewritten; apply rules post-decorrelation
             final HepProgramBuilder builder =
                     HepProgram.builder()
@@ -376,7 +409,7 @@ protected RelNode decorrelate(RelNode root) {
             final HepProgram program2 = builder.build();
 
             final HepPlanner planner2 = createPlanner(program2);
-            final RelNode newRoot = frame.r;
+            final RelNode newRoot = result;
             planner2.setRoot(newRoot);
             return planner2.findBestExp();
         }
@@ -504,14 +537,17 @@ protected RexNode removeCorrelationExpr(
     }
 
     /** Fallback if none of the other {@code decorrelateRel} methods match. */
-    public @Nullable Frame decorrelateRel(RelNode rel, boolean isCorVarDefined) {
+    public @Nullable Frame decorrelateRel(
+            RelNode rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
         RelNode newRel = rel.copy(rel.getTraitSet(), rel.getInputs());
 
         if (!rel.getInputs().isEmpty()) {
             List<RelNode> oldInputs = rel.getInputs();
             List<RelNode> newInputs = new ArrayList<>();
             for (int i = 0; i < oldInputs.size(); ++i) {
-                final Frame frame = getInvoke(oldInputs.get(i), isCorVarDefined, rel);
+                final Frame frame =
+                        getInvoke(
+                                oldInputs.get(i), isCorVarDefined, rel, parentPropagatesNullValues);
                 if (frame == null || !frame.corDefOutputs.isEmpty()) {
                     // if input is not rewritten, or if it produces correlated
                     // variables, terminate rewrite
@@ -535,7 +571,8 @@ protected RexNode removeCorrelationExpr(
                 ImmutableSortedMap.of());
     }
 
-    public @Nullable Frame decorrelateRel(Sort rel, boolean isCorVarDefined) {
+    public @Nullable Frame decorrelateRel(
+            Sort rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
         //
         // Rewrite logic:
         //
@@ -552,7 +589,7 @@ protected RexNode removeCorrelationExpr(
         // need to call propagateExpr.
 
         final RelNode oldInput = rel.getInput();
-        final Frame frame = getInvoke(oldInput, isCorVarDefined, rel);
+        final Frame frame = getInvoke(oldInput, isCorVarDefined, rel, true);
         if (frame == null) {
             // If input has not been rewritten, do not rewrite this rel.
             return null;
@@ -590,16 +627,13 @@ protected RexNode removeCorrelationExpr(
         return register(rel, newSort, frame.oldToNewOutputs, frame.corDefOutputs);
     }
 
-    public @Nullable Frame decorrelateRel(Values rel, boolean isCorVarDefined) {
-        // There are no inputs, so rel does not need to be changed.
-        return null;
-    }
-
-    public @Nullable Frame decorrelateRel(LogicalAggregate rel, boolean isCorVarDefined) {
-        return decorrelateRel((Aggregate) rel, isCorVarDefined);
+    public @Nullable Frame decorrelateRel(
+            LogicalAggregate rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
+        return decorrelateRel((Aggregate) rel, isCorVarDefined, parentPropagatesNullValues);
     }
 
-    public @Nullable Frame decorrelateRel(Aggregate rel, boolean isCorVarDefined) {
+    public @Nullable Frame decorrelateRel(
+            Aggregate rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
         //
         // Rewrite logic:
         //
@@ -613,7 +647,7 @@ protected RexNode removeCorrelationExpr(
         assert !cm.mapRefRelToCorRef.containsKey(rel);
 
         final RelNode oldInput = rel.getInput();
-        final Frame frame = getInvoke(oldInput, isCorVarDefined, rel);
+        final Frame frame = getInvoke(oldInput, isCorVarDefined, rel, parentPropagatesNullValues);
         if (frame == null) {
             // If input has not been rewritten, do not rewrite this rel.
             return null;
@@ -648,7 +682,7 @@ protected RexNode removeCorrelationExpr(
             }
 
             // add mapping of group keys.
-            outputMap.put(idx, newPos);
+            outputMap.put(i, newPos);
             int newInputPos = requireNonNull(frame.oldToNewOutputs.get(idx));
             RexInputRef.add2(projects, newInputPos, newInputOutput);
             mapNewInputToProjOutputs.put(newInputPos, newPos);
@@ -762,9 +796,16 @@ protected RexNode removeCorrelationExpr(
                                     combinedMap.get(oldAggCall.filterArg),
                                     () -> "combinedMap.get(" + oldAggCall.filterArg + ")");
 
+            boolean newHasEmptyGroup = newGroupSets == null && newGroupSet.isEmpty();
+            if (newGroupSets != null) {
+                Iterator<ImmutableBitSet> groupSetsIterator = newGroupSets.iterator();
+                while (!newHasEmptyGroup && groupSetsIterator.hasNext()) {
+                    newHasEmptyGroup |= groupSetsIterator.next().isEmpty();
+                }
+            }
             newAggCalls.add(
                     oldAggCall.adaptTo(
-                            newProject, aggArgs, filterArg, oldGroupKeyCount, newGroupKeyCount));
+                            newProject, aggArgs, filterArg, rel.hasEmptyGroup(), newHasEmptyGroup));
 
             // The old to new output position mapping will be the same as that
             // of newProject, plus any aggregates that the oldAgg produces.
@@ -796,11 +837,161 @@ protected RexNode removeCorrelationExpr(
 
         RelNode newRel = relBuilder.build();
 
+        for (AggregateCall aggCall : rel.getAggCallList()) {
+            if (aggCall.getAggregation() instanceof SqlCountAggFunction) {
+                parentPropagatesNullValues = false;
+                break;
+            }
+        }
+
+        if (rel.getGroupType() == Aggregate.Group.SIMPLE
+                && rel.getGroupSet().isEmpty()
+                && !frame.corDefOutputs.isEmpty()
+                && !parentPropagatesNullValues) {
+            newRel = rewriteScalarAggregate(rel, newRel, outputMap, corDefOutputs);
+        }
+
         // Aggregate does not change input ordering so corVars will be
         // located at the same position as the input newProject.
         return register(rel, newRel, outputMap, corDefOutputs);
     }
 
+    /**
+     * Special case where the group by is static (i.e., aggregation functions without group by).
+     *
+     * <p>Background: For the query: SELECT SUM(salary), COUNT(name) FROM A; When table A is empty,
+     * it returns [null, 0]. But for SELECT SUM(salary), COUNT(name) FROM A group by id When table A
+     * is empty, it returns empty. This causes result mismatch. In the general decorrelation
+     * framework, we add corVar as an additional groupKey to rewrite Correlate as JOIN. (See the
+     * code above for details) This means that when the input is empty, the result produced using a
+     * JOIN is incorrect.
+     *
+     * <p>We refer to this situation as: `The well-known count bug`, More details about this issue:
+     * Optimization of Nested SQL Queries Revisited (https://dl.acm.org/doi/pdf/10.1145/38714.38723)
+     *
+     * <p>To handle this situation, we using a LEFT JOIN to ensure that an output is always
+     * produced.
+     *
+     * <p>Given the SQL: SELECT deptno FROM dept d WHERE 0 = (SELECT COUNT(*) FROM emp e WHERE
+     * d.deptno = e.deptno) Corresponding plan: LogicalProject(DEPTNO=[$0])
+     * LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])
+     * LogicalProject(DEPTNO=[$0]) LogicalTableScan(table=[[scott, DEPT]]) LogicalProject(cs=[true])
+     * LogicalFilter(condition=[=(0, $0)]) LogicalAggregate(group=[{}], EXPR$0=[COUNT()])
+     * LogicalFilter(condition=[=($cor0.DEPTNO, $7)]) LogicalTableScan(table=[[scott, EMP]])
+     *
+     * <p>Rewriting this as: SELECT d.deptno FROM dept d JOIN ( SELECT true, e.deptno FROM emp e
+     * WHERE e.deptno IS NOT NULL GROUP BY e.deptno HAVING COUNT(*) = 0 ) AS d0 ON d.deptno =
+     * d0.deptno produces an incorrect result. Corresponding plan: LogicalProject(DEPTNO=[$0])
+     * LogicalJoin(condition=[=($0, $2)], joinType=[inner]) LogicalProject(DEPTNO=[$0])
+     * LogicalTableScan(table=[[scott, DEPT]]) LogicalProject(cs=[true], DEPTNO=[$0])
+     * LogicalFilter(condition=[=(0, $1)]) LogicalAggregate(group=[{0}], EXPR$0=[COUNT()]) //
+     * corresponds to {@code oldRel} LogicalProject(DEPTNO=[$7]) LogicalFilter(condition=[IS NOT
+     * NULL($7)]) LogicalTableScan(table=[[scott, EMP]]) We can clearly observe that due to the
+     * presence of the GROUP BY clause, COUNT(*) = 0 will never evaluate to true, since rows with
+     * zero records won't appear in the GROUP BY results. This produced incorrect results.
+     *
+     * <p>Rewrite Aggregate as: SELECT d.deptno FROM dept d JOIN ( SELECT true AS cs, deptno FROM (
+     * SELECT d2.deptno, CASE WHEN cnt0 IS NOT NULL THEN cnt0 ELSE 0 END AS cnt FROM (SELECT deptno
+     * FROM dept GROUP BY deptno) d2 LEFT JOIN ( SELECT deptno, COUNT(e.empno) cnt0 FROM emp WHERE
+     * deptno IS NOT NULL GROUP BY deptno) e ON d2.deptno IS NOT DISTINCT FROM e.deptno ) AS
+     * case_count WHERE cnt = 0 ) AS d0 ON d.deptno = d0.deptno Corresponding plan: [01]
+     * LogicalProject(DEPTNO=[$0]) [02] LogicalJoin(condition=[=($0, $2)], joinType=[inner]) [03]
+     * LogicalProject(DEPTNO=[$0]) [04] LogicalTableScan(table=[[scott, DEPT]]) [05]
+     * LogicalProject(cs=[true], DEPTNO=[$0]) [06] LogicalFilter(condition=[=(0, $1)]) [07]
+     * LogicalProject(DEPTNO=[$0], EXPR$0=[CASE(IS NOT NULL($2), $2, 0)]) [08]
+     * LogicalJoin(condition=[IS NOT DISTINCT FROM($0, $1)], joinType=[left]) [09]
+     * LogicalAggregate(group=[{0}]) [10] LogicalProject(DEPTNO=[$0]) [11]
+     * LogicalTableScan(table=[[scott, DEPT]]) [12] LogicalAggregate(group=[{0}], EXPR$0=[COUNT()])
+     * [13] LogicalProject(DEPTNO=[$7]) [14] LogicalFilter(condition=[IS NOT NULL($7)]) [15]
+     * LogicalTableScan(table=[[scott, EMP]])
+     *
+     * <p>Here we perform an early join, preserving all possible CorVar sets from the outer scope
+     * and their corresponding aggregation results. This ensures that for any row from the left
+     * input of the Correlation, there is always an aggregation result available for join output.
+     *
+     * <p>Implementation based on: Improving Unnesting of Complex Queries
+     * (https://dl.gi.de/server/api/core/bitstreams/c1918e8c-6a87-4da2-930a-bfed289f2388/content)
+     */
+    private RelNode rewriteScalarAggregate(
+            Aggregate oldRel,
+            RelNode newRel,
+            Map<Integer, Integer> outputMap,
+            NavigableMap<CorDef, Integer> corDefOutputs) {
+        final Pair<CorrelationId, Frame> outerFramePair = requireNonNull(this.frameStack.peek());
+        final Frame outFrame = outerFramePair.right;
+        RexBuilder rexBuilder = relBuilder.getRexBuilder();
+
+        int groupKeySize =
+                (int)
+                        corDefOutputs.keySet().stream()
+                                .filter(a -> a.corr.equals(outerFramePair.left))
+                                .count();
+        List<RelDataTypeField> newRelFields = newRel.getRowType().getFieldList();
+        ImmutableBitSet.Builder corFieldBuilder = ImmutableBitSet.builder();
+
+        // Here we record the mapping between the original index and the new project.
+        // For the count, we map it as `case when x is null then 0 else x`.
+        final Map<Integer, RexNode> newProjectMap = new HashMap<>();
+        final List<RexNode> conditions = new ArrayList<>();
+        for (Map.Entry<CorDef, Integer> corDefOutput : corDefOutputs.entrySet()) {
+            CorDef corDef = corDefOutput.getKey();
+            Integer corIndex = corDefOutput.getValue();
+            if (corDef.corr.equals(outerFramePair.left)) {
+                int newIdx = requireNonNull(outFrame.oldToNewOutputs.get(corDef.field));
+                corFieldBuilder.set(newIdx);
+
+                RelDataType type = outFrame.r.getRowType().getFieldList().get(newIdx).getType();
+                RexNode left = new RexInputRef(corFieldBuilder.cardinality() - 1, type);
+                newProjectMap.put(corIndex + groupKeySize, left);
+                conditions.add(
+                        relBuilder.isNotDistinctFrom(
+                                left,
+                                new RexInputRef(
+                                        corIndex + groupKeySize,
+                                        newRelFields.get(corIndex).getType())));
+            }
+        }
+
+        ImmutableBitSet groupSet = corFieldBuilder.build();
+        // Build [09] LogicalAggregate(group=[{0}]) to obtain the distinct set of
+        // corVar from outFrame.
+        relBuilder.push(outFrame.r).aggregate(relBuilder.groupKey(groupSet));
+
+        // Build [08] LogicalJoin(condition=[IS NOT DISTINCT FROM($0, $1)], joinType=[left])
+        // to ensure each corVar's aggregate result is output.
+        final RelNode join = relBuilder.push(newRel).join(JoinRelType.LEFT, conditions).build();
+
+        for (int i1 = 0; i1 < oldRel.getAggCallList().size(); i1++) {
+            AggregateCall aggCall = oldRel.getAggCallList().get(i1);
+            if (aggCall.getAggregation() instanceof SqlCountAggFunction) {
+                int index = requireNonNull(outputMap.get(i1 + oldRel.getGroupSet().size()));
+                final RexInputRef ref = RexInputRef.of(index + groupKeySize, join.getRowType());
+                RexNode specificCountValue =
+                        rexBuilder.makeCall(
+                                SqlStdOperatorTable.CASE,
+                                ImmutableList.of(
+                                        relBuilder.isNotNull(ref), ref, relBuilder.literal(0)));
+                newProjectMap.put(ref.getIndex(), specificCountValue);
+            }
+        }
+
+        final List<RexNode> newProjects = new ArrayList<>();
+        for (int index : ImmutableBitSet.range(groupKeySize, join.getRowType().getFieldCount())) {
+            if (newProjectMap.containsKey(index)) {
+                newProjects.add(requireNonNull(newProjectMap.get(index)));
+            } else {
+                newProjects.add(RexInputRef.of(index, join.getRowType()));
+            }
+        }
+
+        // Build [07] LogicalProject(DEPTNO=[$0], EXPR$0=[CASE(IS NOT NULL($2), $2, 0)])
+        // to handle COUNT function by converting nulls to zero.
+        return relBuilder
+                .push(join)
+                .project(newProjects, newRel.getRowType().getFieldNames())
+                .build();
+    }
+
     /**
      * Shift the mapping to fixed offset from the {@code startIndex}.
      *
@@ -817,8 +1008,18 @@ private static void shiftMapping(Map<Integer, Integer> mapping, int startIndex,
         }
     }
 
-    public @Nullable Frame getInvoke(RelNode r, boolean isCorVarDefined, @Nullable RelNode parent) {
-        final Frame frame = dispatcher.invoke(r, isCorVarDefined);
+    /**
+     * Invokes decorrelation logic for a given relational expression.
+     *
+     * @param parentPropagatesNullValues True if the parent RelNode produces null when all of its
+     *     inputs fields are null.
+     */
+    public @Nullable Frame getInvoke(
+            RelNode r,
+            boolean isCorVarDefined,
+            @Nullable RelNode parent,
+            boolean parentPropagatesNullValues) {
+        final Frame frame = dispatcher.invoke(r, isCorVarDefined, parentPropagatesNullValues);
         currentRel = parent;
         if (frame != null) {
             map.put(r, frame);
@@ -985,19 +1186,26 @@ private static void shiftMapping(Map<Integer, Integer> mapping, int startIndex,
         return null;
     }
 
-    public @Nullable Frame decorrelateRel(LogicalProject rel, boolean isCorVarDefined) {
-        return decorrelateRel((Project) rel, isCorVarDefined);
+    public @Nullable Frame decorrelateRel(
+            LogicalProject rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
+        return decorrelateRel((Project) rel, isCorVarDefined, parentPropagatesNullValues);
     }
 
-    public @Nullable Frame decorrelateRel(Project rel, boolean isCorVarDefined) {
+    public @Nullable Frame decorrelateRel(
+            Project rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
         //
         // Rewrite logic:
         //
         // 1. Pass along any correlated variables coming from the input.
         //
+        for (RexNode project : rel.getProjects()) {
+            if (!Strong.isStrong(project)) {
+                parentPropagatesNullValues = false;
+            }
+        }
 
         final RelNode oldInput = rel.getInput();
-        Frame frame = getInvoke(oldInput, isCorVarDefined, rel);
+        Frame frame = getInvoke(oldInput, isCorVarDefined, rel, parentPropagatesNullValues);
         if (frame == null) {
             // If input has not been rewritten, do not rewrite this rel.
             return null;
@@ -1361,25 +1569,31 @@ private static boolean isWidening(RelDataType type, RelDataType type1) {
                 && type.getPrecision() >= type1.getPrecision();
     }
 
-    public @Nullable Frame decorrelateRel(LogicalSnapshot rel, boolean isCorVarDefined) {
+    public @Nullable Frame decorrelateRel(
+            LogicalSnapshot rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
         if (RexUtil.containsCorrelation(rel.getPeriod())) {
             return null;
         }
-        return decorrelateRel((RelNode) rel, isCorVarDefined);
+        return decorrelateRel((RelNode) rel, isCorVarDefined, parentPropagatesNullValues);
     }
 
-    public @Nullable Frame decorrelateRel(LogicalTableFunctionScan rel, boolean isCorVarDefined) {
+    public @Nullable Frame decorrelateRel(
+            LogicalTableFunctionScan rel,
+            boolean isCorVarDefined,
+            boolean parentPropagatesNullValues) {
         if (RexUtil.containsCorrelation(rel.getCall())) {
             return null;
         }
-        return decorrelateRel((RelNode) rel, isCorVarDefined);
+        return decorrelateRel((RelNode) rel, isCorVarDefined, parentPropagatesNullValues);
     }
 
-    public @Nullable Frame decorrelateRel(LogicalFilter rel, boolean isCorVarDefined) {
-        return decorrelateRel((Filter) rel, isCorVarDefined);
+    public @Nullable Frame decorrelateRel(
+            LogicalFilter rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
+        return decorrelateRel((Filter) rel, isCorVarDefined, parentPropagatesNullValues);
     }
 
-    public @Nullable Frame decorrelateRel(Filter rel, boolean isCorVarDefined) {
+    public @Nullable Frame decorrelateRel(
+            Filter rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
         //
         // Rewrite logic:
         //
@@ -1397,7 +1611,7 @@ private static boolean isWidening(RelDataType type, RelDataType type1) {
         //
 
         final RelNode oldInput = rel.getInput();
-        Frame frame = getInvoke(oldInput, isCorVarDefined, rel);
+        Frame frame = getInvoke(oldInput, isCorVarDefined, rel, parentPropagatesNullValues);
         if (frame == null) {
             // If input has not been rewritten, do not rewrite this rel.
             return null;
@@ -1428,11 +1642,13 @@ private static boolean isWidening(RelDataType type, RelDataType type1) {
         return register(rel, relBuilder.build(), frame.oldToNewOutputs, frame.corDefOutputs);
     }
 
-    public @Nullable Frame decorrelateRel(LogicalCorrelate rel, boolean isCorVarDefined) {
-        return decorrelateRel((Correlate) rel, isCorVarDefined);
+    public @Nullable Frame decorrelateRel(
+            LogicalCorrelate rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
+        return decorrelateRel((Correlate) rel, isCorVarDefined, parentPropagatesNullValues);
     }
 
-    public @Nullable Frame decorrelateRel(Correlate rel, boolean isCorVarDefined) {
+    public @Nullable Frame decorrelateRel(
+            Correlate rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
         //
         // Rewrite logic:
         //
@@ -1446,15 +1662,18 @@ private static boolean isWidening(RelDataType type, RelDataType type1) {
         final RelNode oldLeft = rel.getInput(0);
         final RelNode oldRight = rel.getInput(1);
 
-        final Frame leftFrame = getInvoke(oldLeft, isCorVarDefined, rel);
-        final Frame rightFrame = getInvoke(oldRight, true, rel);
-
-        if (leftFrame == null || rightFrame == null) {
-            // If any input has not been rewritten, do not rewrite this rel.
+        final Frame leftFrame =
+                getInvoke(oldLeft, isCorVarDefined, rel, parentPropagatesNullValues);
+        if (leftFrame == null) {
+            // If input has not been rewritten, do not rewrite this rel.
             return null;
         }
 
-        if (rightFrame.corDefOutputs.isEmpty()) {
+        frameStack.push(Pair.of(rel.getCorrelationId(), leftFrame));
+        final Frame rightFrame = getInvoke(oldRight, true, rel, parentPropagatesNullValues);
+        frameStack.pop();
+
+        if (rightFrame == null || rightFrame.corDefOutputs.isEmpty()) {
             return null;
         }
 
@@ -1542,16 +1761,18 @@ private static boolean isWidening(RelDataType type, RelDataType type1) {
         return register(rel, newJoin, mapOldToNewOutputs, corDefOutputs);
     }
 
-    public @Nullable Frame decorrelateRel(LogicalJoin rel, boolean isCorVarDefined) {
-        return decorrelateRel((Join) rel, isCorVarDefined);
+    public @Nullable Frame decorrelateRel(
+            LogicalJoin rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
+        return decorrelateRel((Join) rel, isCorVarDefined, parentPropagatesNullValues);
     }
 
-    public @Nullable Frame decorrelateRel(Join rel, boolean isCorVarDefined) {
+    public @Nullable Frame decorrelateRel(
+            Join rel, boolean isCorVarDefined, boolean parentPropagatesNullValues) {
         // For SEMI/ANTI join decorrelate it's input directly,
         // because the correlate variables can only be propagated from
         // the left side, which is not supported yet.
         if (!rel.getJoinType().projectsRight()) {
-            return decorrelateRel((RelNode) rel, isCorVarDefined);
+            return decorrelateRel((RelNode) rel, isCorVarDefined, parentPropagatesNullValues);
         }
         //
         // Rewrite logic:
@@ -1563,8 +1784,10 @@ private static boolean isWidening(RelDataType type, RelDataType type1) {
         final RelNode oldLeft = rel.getInput(0);
         final RelNode oldRight = rel.getInput(1);
 
-        final Frame leftFrame = getInvoke(oldLeft, isCorVarDefined, rel);
-        final Frame rightFrame = getInvoke(oldRight, isCorVarDefined, rel);
+        final Frame leftFrame =
+                getInvoke(oldLeft, isCorVarDefined, rel, parentPropagatesNullValues);
+        final Frame rightFrame =
+                getInvoke(oldRight, isCorVarDefined, rel, parentPropagatesNullValues);
 
         if (leftFrame == null || rightFrame == null) {
             // If any input has not been rewritten, do not rewrite this rel.
@@ -2764,8 +2987,8 @@ public void onMatch(RelOptRuleCall call) {
                                 joinOutputProject,
                                 argList,
                                 filterArg,
-                                aggregate.getGroupCount(),
-                                groupCount));
+                                aggregate.hasEmptyGroup(),
+                                groupCount == 0));
             }
 
             ImmutableBitSet groupSet = ImmutableBitSet.range(groupCount);
@@ -2876,7 +3099,7 @@ public void onMatch(RelOptRuleCall call) {
             onMatch2(d, call, correlate, left, aggOutputProject, aggregate);
         }
 
-        private void onMatch2(
+        private static void onMatch2(
                 RelDecorrelator d,
                 RelOptRuleCall call,
                 Correlate correlate,
@@ -3297,6 +3520,8 @@ assert allLessThan(
                     Litmus.THROW);
             assert allLessThan(
                     this.oldToNewOutputs.values(), r.getRowType().getFieldCount(), Litmus.THROW);
+            RelDataType rowType = oldRel.getRowType();
+            assert this.oldToNewOutputs.size() >= rowType.getFieldCount();
         }
     }
 
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
index abb0e9a882312..46a3e89c3de82 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
@@ -49,6 +49,7 @@
 import org.apache.calcite.rel.RelCollationTraitDef;
 import org.apache.calcite.rel.RelCollations;
 import org.apache.calcite.rel.RelFieldCollation;
+import org.apache.calcite.rel.RelHomogeneousShuttle;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.RelRoot;
 import org.apache.calcite.rel.RelShuttleImpl;
@@ -101,6 +102,7 @@
 import org.apache.calcite.rex.RexPatternFieldRef;
 import org.apache.calcite.rex.RexRangeRef;
 import org.apache.calcite.rex.RexShuttle;
+import org.apache.calcite.rex.RexSimplify;
 import org.apache.calcite.rex.RexSubQuery;
 import org.apache.calcite.rex.RexUtil;
 import org.apache.calcite.rex.RexWindowBound;
@@ -1168,6 +1170,16 @@ private static SqlNode reg(SqlValidatorScope scope, SqlNode e) {
         return e;
     }
 
+    private RexNode simplifyPredicate(RexNode predicate) {
+        final RexNode converted = RexUtil.removeNullabilityCast(typeFactory, predicate);
+        List<RexNode> conjuncts = RelOptUtil.conjunctions(converted);
+        List<RexNode> simplified =
+                conjuncts.stream()
+                        .map(e -> RexSimplify.simplifyComparisonWithNull(e, rexBuilder))
+                        .collect(Collectors.toList());
+        return RexUtil.composeConjunction(rexBuilder, simplified);
+    }
+
     /**
      * Converts a WHERE clause.
      *
@@ -1181,7 +1193,7 @@ private void convertWhere(final Blackboard bb, final @Nullable SqlNode where) {
         SqlNode newWhere = pushDownNotForIn(bb.scope, where);
         replaceSubQueries(bb, newWhere, RelOptUtil.Logic.UNKNOWN_AS_FALSE);
         final RexNode convertedWhere = bb.convertExpression(newWhere);
-        final RexNode convertedWhere2 = RexUtil.removeNullabilityCast(typeFactory, convertedWhere);
+        final RexNode convertedWhere2 = simplifyPredicate(convertedWhere);
 
         // only allocate filter if the condition is not TRUE
         if (convertedWhere2.isAlwaysTrue()) {
@@ -1284,23 +1296,8 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
 
                 if (!config.isExpand()) {
                     if (query instanceof SqlNodeList) {
-                        // convert
-                        // select * from "scott".emp where sal > some (4000, 2000)
-                        // to
-                        // select * from "scott".emp where sal > some (VALUES (4000), (2000))
-                        // The SqlNodeList become a RexSubQuery then optimized by
-                        // SubQueryRemoveRule.
-                        RelNode relNode =
-                                convertRowValues(
-                                        bb, query, (SqlNodeList) query, false, targetRowType);
-                        final ImmutableList.Builder<RexNode> builder = ImmutableList.builder();
-                        for (SqlNode node : leftSqlKeys) {
-                            builder.add(bb.convertExpression(node));
-                        }
-                        final ImmutableList<RexNode> list = builder.build();
-                        assert relNode != null;
-                        subQuery.expr =
-                                createSubquery(subQuery.node.getKind(), relNode, list, call);
+                        convertNodeListToSubQuery(
+                                bb, subQuery, query, leftSqlKeys, targetRowType, call);
                         return;
                     }
                     return;
@@ -1339,7 +1336,12 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
                 //
                 // In such case, when converting SqlUpdate#condition, bb.root is null
                 // and it makes no sense to do the sub-query substitution.
+                // Instead, we convert to a RexSubQuery which can be optimized later.
                 if (bb.root == null) {
+                    if (query instanceof SqlNodeList) {
+                        convertNodeListToSubQuery(
+                                bb, subQuery, query, leftSqlKeys, targetRowType, call);
+                    }
                     return;
                 }
 
@@ -1921,6 +1923,48 @@ private RexNode ensureComparisonTypes(RexNode node) {
         return node;
     }
 
+    /**
+     * Converts a {@link SqlNodeList} (for example an IN-list or VALUES list) into a relational
+     * expression and produces a Rex-level sub-query that references that relational expression.
+     *
+     * <p>For example, converts:
+     *
+     * <pre>{@code
+     * select * from "scott".emp where sal > some (4000, 2000)
+     * }</pre>
+     *
+     * to:
+     *
+     * <pre>{@code
+     * select * from "scott".emp where sal > some (VALUES (4000), (2000))
+     * }</pre>
+     *
+     * The SqlNodeList becomes a RexSubQuery then optimized by SubQueryRemoveRule.
+     *
+     * @param bb Blackboard containing the context
+     * @param subQuery The SubQuery to populate with the converted expression
+     * @param query The query node (expected to be a SqlNodeList)
+     * @param leftSqlKeys Left-hand key expressions for IN/SOME/ALL
+     * @param targetRowType The target row type for the conversion
+     * @param call The original SQL call
+     */
+    private void convertNodeListToSubQuery(
+            Blackboard bb,
+            SubQuery subQuery,
+            SqlNode query,
+            List<SqlNode> leftSqlKeys,
+            RelDataType targetRowType,
+            SqlCall call) {
+        RelNode relNode = convertRowValues(bb, query, (SqlNodeList) query, false, targetRowType);
+        final ImmutableList.Builder<RexNode> builder = ImmutableList.builder();
+        for (SqlNode node : leftSqlKeys) {
+            builder.add(bb.convertExpression(node));
+        }
+        final ImmutableList<RexNode> list = builder.build();
+        assert relNode != null;
+        subQuery.expr = createSubquery(subQuery.node.getKind(), relNode, list, call);
+    }
+
     /**
      * Gets the list size threshold under which {@link #convertInToOr} is used. Lists of this size
      * or greater will instead be converted to use a join against an inline table ({@link
@@ -2670,15 +2714,15 @@ protected void convertFrom(
                 convertCollectionTable(bb, call2);
                 return;
 
-            // ----- FLINK MODIFICATION BEGIN -----
             case LATERAL:
                 call = (SqlCall) from;
+
                 // Extract and analyze lateral part of join call.
                 assert call.getOperandList().size() == 1;
                 final SqlCall callLateral = call.operand(0);
                 convertFrom(bb, callLateral, fieldNames);
                 return;
-            // ----- FLINK MODIFICATION END -----
+
             default:
                 throw new AssertionError("not a join operator " + from);
         }
@@ -3350,12 +3394,8 @@ protected RelNode createAsofJoin(
         }
         final ImmutableBitSet.Builder requiredColumns = ImmutableBitSet.builder();
         final List<CorrelationId> correlNames = new ArrayList<>();
-
-        // All correlations must refer the same namespace since correlation
-        // produces exactly one correlation source.
-        // The same source might be referenced by different variables since
-        // DeferredLookups are not de-duplicated at create time.
-        SqlValidatorNamespace prevNs = null;
+        // Mapping from (correlId, originalFieldIndex) to projectedFieldIndex for aggregation
+        final Map<Pair<CorrelationId, Integer>, Integer> fieldMapping = new HashMap<>();
 
         for (CorrelationId correlName : correlatedVariables) {
             DeferredLookup lookup =
@@ -3371,7 +3411,6 @@ protected RelNode createAsofJoin(
                     ImmutableList.of(lookup.originalRelName), nameMatcher, false, resolved);
             assert resolved.count() == 1;
             final SqlValidatorScope.Resolve resolve = resolved.only();
-            final SqlValidatorNamespace foundNs = resolve.namespace;
             final RelDataType rowType = resolve.rowType();
             final int childNamespaceIndex = resolve.path.steps().get(0).i;
             final SqlValidatorScope ancestorScope = resolve.scope;
@@ -3381,18 +3420,6 @@ protected RelNode createAsofJoin(
                 continue;
             }
 
-            if (prevNs == null) {
-                prevNs = foundNs;
-            } else {
-                assert prevNs == foundNs
-                        : "All correlation variables should resolve"
-                                + " to the same namespace."
-                                + " Prev ns="
-                                + prevNs
-                                + ", new ns="
-                                + foundNs;
-            }
-
             int namespaceOffset = 0;
             if (childNamespaceIndex > 0) {
                 // If not the first child, need to figure out the width
@@ -3410,9 +3437,9 @@ protected RelNode createAsofJoin(
             while (topLevelFieldAccess.getReferenceExpr() instanceof RexFieldAccess) {
                 topLevelFieldAccess = (RexFieldAccess) topLevelFieldAccess.getReferenceExpr();
             }
+            final int originalFieldIndex = topLevelFieldAccess.getField().getIndex();
             final RelDataTypeField field =
-                    rowType.getFieldList()
-                            .get(topLevelFieldAccess.getField().getIndex() - namespaceOffset);
+                    rowType.getFieldList().get(originalFieldIndex - namespaceOffset);
             int pos = namespaceOffset + field.getIndex();
 
             assert field.getType() == topLevelFieldAccess.getField().getType();
@@ -3427,6 +3454,7 @@ protected RelNode createAsofJoin(
                 // the root of the outer relation.
                 Integer projection = exprProjection.get(pos);
                 if (projection != null) {
+                    fieldMapping.put(Pair.of(correlName, originalFieldIndex), projection);
                     pos = projection;
                 } else {
                     // correl not grouped
@@ -3458,6 +3486,19 @@ protected RelNode createAsofJoin(
             // Add new node to leaves.
             leaves.put(r, r.getRowType().getFieldCount());
         }
+
+        // If there are field mappings (due to aggregation), rewrite the RelNode tree
+        // to update correlation variable row type and field indices
+        if (!fieldMapping.isEmpty()) {
+            r =
+                    r.accept(
+                            new CorrelationFieldMappingShuttle(
+                                    rexBuilder,
+                                    correlNames.get(0),
+                                    bb.root().getRowType(),
+                                    fieldMapping));
+        }
+
         return new CorrelationUse(correlNames.get(0), requiredColumns.build(), r);
     }
 
@@ -3532,7 +3573,7 @@ private void convertJoin(Blackboard bb, SqlJoin join) {
         final RelNode tempRightRel = requireNonNull(rightBlackboard.root, "rightBlackboard.root");
 
         final JoinConditionType conditionType = join.getConditionType();
-        final RexNode condition;
+        RexNode condition;
         RelNode rightRel;
         if (join.isNatural()) {
             condition = convertNaturalCondition(getNamespace(left), getNamespace(right));
@@ -3561,6 +3602,8 @@ private void convertJoin(Blackboard bb, SqlJoin join) {
                     throw Util.unexpected(conditionType);
             }
         }
+        condition = simplifyPredicate(condition);
+
         final RelNode joinRel;
         if (joinType == JoinType.ASOF || joinType == JoinType.LEFT_ASOF) {
             SqlNode sqlMatchCondition =
@@ -3570,6 +3613,7 @@ private void convertJoin(Blackboard bb, SqlJoin join) {
             Pair<RexNode, RelNode> conditionAndRightNode =
                     convertOnCondition(fromBlackboard, sqlMatchCondition, leftRel, tempRightRel);
             RexNode matchCondition = conditionAndRightNode.left;
+            matchCondition = simplifyPredicate(matchCondition);
             rightRel = conditionAndRightNode.right;
             joinRel =
                     createAsofJoin(
@@ -4666,14 +4710,27 @@ private RelNode convertUpdate(SqlUpdate call) {
             targetColumnNameList.add(field.getName());
         }
 
-        RelNode sourceRel = convertSelect(sourceSelect, false);
+        // `sourceSelect` should contain target columns values plus source expressions
+        if (sourceSelect.getSelectList().size()
+                != targetTable.getRowType().getFieldCount()
+                        + call.getSourceExpressionList().size()) {
+            throw new AssertionError(
+                    "Unexpected select list size. Select list should contain both target table columns and "
+                            + "set expressions");
+        }
 
+        RelNode sourceRel = convertSelect(sourceSelect, false);
         bb.setRoot(sourceRel, false);
-        ImmutableList.Builder<RexNode> rexNodeSourceExpressionListBuilder = ImmutableList.builder();
-        for (SqlNode n : call.getSourceExpressionList()) {
-            RexNode rn = bb.convertExpression(n);
-            rexNodeSourceExpressionListBuilder.add(rn);
-        }
+
+        // sourceRel already contains all source expressions. Only create references to those
+        // fields.
+        List<RexNode> rexExpressionList =
+                Util.transform(
+                        Util.last(
+                                sourceRel.getRowType().getFieldList(), targetColumnNameList.size()),
+                        expressionField ->
+                                new RexInputRef(
+                                        expressionField.getIndex(), expressionField.getType()));
 
         return LogicalTableModify.create(
                 targetTable,
@@ -4681,7 +4738,7 @@ private RelNode convertUpdate(SqlUpdate call) {
                 sourceRel,
                 LogicalTableModify.Operation.UPDATE,
                 targetColumnNameList,
-                rexNodeSourceExpressionListBuilder.build(),
+                rexExpressionList,
                 false);
     }
 
@@ -5009,7 +5066,7 @@ public SqlNode getNode() {
                 case ARRAY_QUERY_CONSTRUCTOR:
                 case MAP_QUERY_CONSTRUCTOR:
                     final RelRoot root = convertQuery(call.operand(0), false, true);
-                    input = root.rel;
+                    input = root.project();
                     break;
                 default:
                     lastList.add(operand);
@@ -5315,6 +5372,7 @@ private void convertValuesImpl(
             mapping = null;
         }
 
+        List<RelDataTypeField> fields = targetRowType.getFieldList();
         for (SqlNode rowConstructor : values.getOperandList()) {
             SqlCall newRowConst = (SqlCall) rowConstructor;
             Blackboard tmpBb = createBlackboard(bb.scope, null, false);
@@ -5323,6 +5381,7 @@ private void convertValuesImpl(
             Ord.forEach(
                     newRowConst.getOperandList(),
                     (operand, i) -> {
+                        RelDataType fieldType = fields.get(i).getType();
                         RexNode def;
                         if (processDefaults
                                 && operand.getKind() == SqlKind.DEFAULT
@@ -5336,6 +5395,9 @@ && requireNonNull(mapping, "mapping")[i] != -1) {
                         } else {
                             def = tmpBb.convertExpression(operand);
                         }
+                        if (!(def instanceof RexDynamicParam) && !def.getType().equals(fieldType)) {
+                            def = rexBuilder.makeCast(operand.getParserPosition(), fieldType, def);
+                        }
                         exps.add(def, SqlValidatorUtil.alias(operand, i));
                     });
 
@@ -5937,20 +5999,20 @@ public RexNode convertExpression(SqlNode expr) {
                         query = Iterables.getOnlyElement(call.getOperandList());
                         // let top=true to make the query be top-level query,
                         // then ORDER BY will be reserved.
-                        root = convertQueryRecursive(query, true, null);
-                        return RexSubQuery.array(root.rel);
+                        root = convertQuery(query, false, true);
+                        return RexSubQuery.array(root.project());
 
                     case MAP_QUERY_CONSTRUCTOR:
                         call = (SqlCall) expr;
                         query = Iterables.getOnlyElement(call.getOperandList());
-                        root = convertQueryRecursive(query, false, null);
-                        return RexSubQuery.map(root.rel);
+                        root = convertQuery(query, false, true);
+                        return RexSubQuery.map(root.project());
 
                     case MULTISET_QUERY_CONSTRUCTOR:
                         call = (SqlCall) expr;
                         query = Iterables.getOnlyElement(call.getOperandList());
-                        root = convertQueryRecursive(query, false, null);
-                        return RexSubQuery.multiset(root.rel);
+                        root = convertQuery(query, false, true);
+                        return RexSubQuery.multiset(root.project());
 
                     default:
                         break;
@@ -6157,14 +6219,14 @@ private boolean isConvertedSubq(RexNode rex) {
         }
 
         @Override
-        public int getGroupCount() {
+        public boolean hasEmptyGroup() {
             if (agg != null) {
-                return agg.groupExprs.size();
+                return SqlValidatorUtil.hasEmptyGroup(agg.groupExprs);
             }
             if (window != null) {
-                return window.isAlwaysNonEmpty() ? 1 : 0;
+                return !window.isAlwaysNonEmpty();
             }
-            return -1;
+            return false;
         }
 
         @Override
@@ -6323,6 +6385,60 @@ RexFieldAccess getFieldAccess(CorrelationId name) {
         }
     }
 
+    /**
+     * Shuttle that rewrites correlation field accesses to use projected field indices when
+     * correlation references aggregated relations.
+     */
+    private static class CorrelationFieldMappingShuttle extends RelHomogeneousShuttle {
+        private final RexBuilder rexBuilder;
+        private final CorrelationId targetCorrelId;
+        private final RelDataType newCorrelRowType;
+        private final Map<Pair<CorrelationId, Integer>, Integer> fieldMapping;
+
+        CorrelationFieldMappingShuttle(
+                RexBuilder rexBuilder,
+                CorrelationId targetCorrelId,
+                RelDataType newCorrelRowType,
+                Map<Pair<CorrelationId, Integer>, Integer> fieldMapping) {
+            this.rexBuilder = rexBuilder;
+            this.targetCorrelId = targetCorrelId;
+            this.newCorrelRowType = newCorrelRowType;
+            this.fieldMapping = fieldMapping;
+        }
+
+        @Override
+        public RelNode visit(RelNode other) {
+            return super.visit(other)
+                    .accept(
+                            new RexShuttle() {
+                                @Override
+                                public RexNode visitFieldAccess(RexFieldAccess fieldAccess) {
+                                    if (fieldAccess.getReferenceExpr()
+                                            instanceof RexCorrelVariable) {
+                                        RexCorrelVariable correlVar =
+                                                (RexCorrelVariable) fieldAccess.getReferenceExpr();
+                                        if (correlVar.id.equals(targetCorrelId)) {
+                                            Integer newIndex =
+                                                    fieldMapping.get(
+                                                            Pair.of(
+                                                                    correlVar.id,
+                                                                    fieldAccess
+                                                                            .getField()
+                                                                            .getIndex()));
+                                            if (newIndex != null) {
+                                                return rexBuilder.makeFieldAccess(
+                                                        rexBuilder.makeCorrel(
+                                                                newCorrelRowType, correlVar.id),
+                                                        newIndex);
+                                            }
+                                        }
+                                    }
+                                    return super.visitFieldAccess(fieldAccess);
+                                }
+                            });
+        }
+    }
+
     /** A default implementation of SubQueryConverter that does no conversion. */
     private static class NoOpSubQueryConverter implements SubQueryConverter {
         @Override
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/common/CommonExecMatch.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/common/CommonExecMatch.java
index 8da68878070a6..3e8918d181020 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/common/CommonExecMatch.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/common/CommonExecMatch.java
@@ -34,6 +34,7 @@
 import org.apache.flink.streaming.api.operators.ChainingStrategy;
 import org.apache.flink.streaming.api.transformations.OneInputTransformation;
 import org.apache.flink.table.api.TableException;
+import org.apache.flink.table.api.ValidationException;
 import org.apache.flink.table.data.RowData;
 import org.apache.flink.table.planner.codegen.CodeGenUtils;
 import org.apache.flink.table.planner.codegen.CodeGeneratorContext;
@@ -68,6 +69,7 @@
 import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexNodeAndFieldIndex;
 import org.apache.calcite.sql.SqlMatchRecognize;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
@@ -367,6 +369,12 @@ public Pattern<RowData, RowData> visitCall(RexCall call) {
             }
         }
 
+        @Override
+        public Pattern<RowData, RowData> visitNodeAndFieldIndex(
+                RexNodeAndFieldIndex nodeAndFieldIndex) {
+            throw new ValidationException("not supported yet");
+        }
+
         @Override
         public Pattern<RowData, RowData> visitNode(RexNode rexNode) {
             throw new TableException(
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/LogicalCorrelateToJoinFromTemporalTableFunctionRule.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/LogicalCorrelateToJoinFromTemporalTableFunctionRule.java
index d80062919e505..55a2f7d6b482f 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/LogicalCorrelateToJoinFromTemporalTableFunctionRule.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/LogicalCorrelateToJoinFromTemporalTableFunctionRule.java
@@ -49,6 +49,7 @@
 import org.apache.calcite.rex.RexFieldAccess;
 import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexNodeAndFieldIndex;
 import org.apache.calcite.rex.RexVisitorImpl;
 import org.apache.calcite.sql.SqlOperator;
 import org.immutables.value.Value;
@@ -336,6 +337,11 @@ public RexNode visitFieldAccess(RexFieldAccess fieldAccess) {
         return rexBuilder.makeInputRef(leftSide, leftIndex);
     }
 
+    @Override
+    public RexNode visitNodeAndFieldIndex(RexNodeAndFieldIndex nodeAndFieldIndex) {
+        throw new ValidationException("not supported yet");
+    }
+
     @Override
     public RexNode visitInputRef(RexInputRef inputRef) {
         return inputRef;
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/RemoteCorrelateSplitRule.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/RemoteCorrelateSplitRule.java
index 1515b0975ff88..005f4bf054049 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/RemoteCorrelateSplitRule.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/RemoteCorrelateSplitRule.java
@@ -18,6 +18,7 @@
 
 package org.apache.flink.table.planner.plan.rules.logical;
 
+import org.apache.flink.table.api.ValidationException;
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalCalc;
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalCorrelate;
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalTableFunctionScan;
@@ -37,6 +38,7 @@
 import org.apache.calcite.rex.RexFieldAccess;
 import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexNodeAndFieldIndex;
 import org.apache.calcite.rex.RexProgram;
 import org.apache.calcite.rex.RexProgramBuilder;
 import org.apache.calcite.rex.RexUtil;
@@ -131,6 +133,11 @@ public RexNode visitFieldAccess(RexFieldAccess fieldAccess) {
                         }
                     }
 
+                    @Override
+                    public RexNode visitNodeAndFieldIndex(RexNodeAndFieldIndex nodeAndFieldIndex) {
+                        throw new ValidationException("not supported yet");
+                    }
+
                     @Override
                     public RexNode visitCall(RexCall call) {
                         List<RexNode> newProjects =
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/SplitPythonConditionFromCorrelateRule.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/SplitPythonConditionFromCorrelateRule.java
index f284644717631..0a1acd46b23ae 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/SplitPythonConditionFromCorrelateRule.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/logical/SplitPythonConditionFromCorrelateRule.java
@@ -18,6 +18,7 @@
 
 package org.apache.flink.table.planner.plan.rules.logical;
 
+import org.apache.flink.table.api.ValidationException;
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalCalc;
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalCorrelate;
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalRel;
@@ -34,6 +35,7 @@
 import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexNodeAndFieldIndex;
 import org.apache.calcite.rex.RexProgram;
 import org.apache.calcite.rex.RexProgramBuilder;
 import org.apache.calcite.rex.RexUtil;
@@ -217,6 +219,11 @@ public RexNode visitCall(RexCall call) {
                             .collect(Collectors.toList()));
         }
 
+        @Override
+        public RexNode visitNodeAndFieldIndex(RexNodeAndFieldIndex nodeAndFieldIndex) {
+            throw new ValidationException("not supported yet");
+        }
+
         @Override
         public RexNode visitNode(RexNode rexNode) {
             return rexNode;
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/physical/common/CommonPhysicalMatchRule.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/physical/common/CommonPhysicalMatchRule.java
index 5476fbbbebeed..8766292dca29d 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/physical/common/CommonPhysicalMatchRule.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/rules/physical/common/CommonPhysicalMatchRule.java
@@ -37,6 +37,7 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexNodeAndFieldIndex;
 import org.apache.calcite.sql.SqlAggFunction;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.util.ImmutableBitSet;
@@ -169,6 +170,11 @@ public Object visitCall(RexCall call) {
             return null;
         }
 
+        @Override
+        public Object visitNodeAndFieldIndex(RexNodeAndFieldIndex nodeAndFieldIndex) {
+            throw new ValidationException("not supported yet");
+        }
+
         @Override
         public Object visitNode(RexNode rexNode) {
             return null;
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/AsyncUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/AsyncUtil.java
index e283252b7043a..70ff3ce25fb4e 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/AsyncUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/AsyncUtil.java
@@ -18,6 +18,7 @@
 
 package org.apache.flink.table.planner.plan.utils;
 
+import org.apache.flink.table.api.ValidationException;
 import org.apache.flink.table.functions.FunctionDefinition;
 import org.apache.flink.table.functions.FunctionKind;
 import org.apache.flink.table.planner.plan.rules.logical.RemoteCallFinder;
@@ -26,6 +27,7 @@
 
 import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexNodeAndFieldIndex;
 
 /** Utility class for working with async function calls in RexNodes. */
 public class AsyncUtil {
@@ -135,6 +137,11 @@ public Boolean visitCall(RexCall call) {
                     || (recursive
                             && call.getOperands().stream().anyMatch(node -> node.accept(this)));
         }
+
+        @Override
+        public Boolean visitNodeAndFieldIndex(RexNodeAndFieldIndex nodeAndFieldIndex) {
+            throw new ValidationException("not supported yet");
+        }
     }
 
     /**
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/ConstantFoldingUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/ConstantFoldingUtil.java
index c8e3e40d7a313..23e62a406f0a5 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/ConstantFoldingUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/ConstantFoldingUtil.java
@@ -18,11 +18,13 @@
 
 package org.apache.flink.table.planner.plan.utils;
 
+import org.apache.flink.table.api.ValidationException;
 import org.apache.flink.table.functions.FunctionDefinition;
 import org.apache.flink.table.planner.utils.ShortcutUtils;
 
 import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexNodeAndFieldIndex;
 
 /** Utility for deciding whether than expression supports constant folding or not. */
 public class ConstantFoldingUtil {
@@ -55,5 +57,10 @@ public Boolean visitCall(RexCall call) {
             return supportsConstantFolding
                     && (call.getOperands().stream().allMatch(node -> node.accept(this)));
         }
+
+        @Override
+        public Boolean visitNodeAndFieldIndex(RexNodeAndFieldIndex nodeAndFieldIndex) {
+            throw new ValidationException("not supported yet");
+        }
     }
 }
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/PythonUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/PythonUtil.java
index 65efb05f430ef..07c29b83407ae 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/PythonUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/plan/utils/PythonUtil.java
@@ -18,6 +18,7 @@
 
 package org.apache.flink.table.planner.plan.utils;
 
+import org.apache.flink.table.api.ValidationException;
 import org.apache.flink.table.functions.DeclarativeAggregateFunction;
 import org.apache.flink.table.functions.FunctionDefinition;
 import org.apache.flink.table.functions.python.PythonFunction;
@@ -39,6 +40,7 @@
 import org.apache.calcite.rex.RexFieldAccess;
 import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexNodeAndFieldIndex;
 import org.apache.calcite.sql.SqlAggFunction;
 import org.apache.calcite.sql.SqlKind;
 
@@ -272,6 +274,11 @@ public Boolean visitFieldAccess(RexFieldAccess fieldAccess) {
             return fieldAccess.getReferenceExpr().accept(this);
         }
 
+        @Override
+        public Boolean visitNodeAndFieldIndex(RexNodeAndFieldIndex nodeAndFieldIndex) {
+            throw new ValidationException("not supported yet");
+        }
+
         @Override
         public Boolean visitNode(RexNode rexNode) {
             return false;
@@ -304,6 +311,11 @@ public Boolean visitFieldAccess(RexFieldAccess fieldAccess) {
             }
         }
 
+        @Override
+        public Boolean visitNodeAndFieldIndex(RexNodeAndFieldIndex nodeAndFieldIndex) {
+            throw new ValidationException("not supported yet");
+        }
+
         @Override
         public Boolean visitCall(RexCall call) {
             if (call.getKind() == SqlKind.AS) {
diff --git a/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE b/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
index 0688c621bf0b6..943be5e3d5ff0 100644
--- a/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
+++ b/flink-table/flink-table-planner/src/main/resources/META-INF/NOTICE
@@ -8,13 +8,13 @@ This project bundles the following dependencies under the Apache Software Licens
 
 - com.google.guava:guava:33.4.0-jre
 - com.google.guava:failureaccess:1.0.2
-- org.apache.calcite:calcite-core:1.40.0
-- org.apache.calcite:calcite-linq4j:1.40.0
-- org.apache.calcite.avatica:avatica-core:1.26.0
+- org.apache.calcite:calcite-core:1.41.0
+- org.apache.calcite:calcite-linq4j:1.41.0
+- org.apache.calcite.avatica:avatica-core:1.27.0
 - org.apache.commons:commons-math3:3.6.1
-- org.apache.commons:commons-text:1.10.0
 - commons-codec:commons-codec:1.15
 - commons-io:commons-io:2.15.1
+- org.jooq:joou-java-6:0.9.4
 
 This project bundles the following dependencies under the MIT License. (http://www.opensource.org/licenses/mit-license.php)
 
diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/codegen/ExprCodeGenerator.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/codegen/ExprCodeGenerator.scala
index b05eac28261ba..9427dace35da5 100644
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/codegen/ExprCodeGenerator.scala
+++ b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/codegen/ExprCodeGenerator.scala
@@ -1026,4 +1026,9 @@ class ExprCodeGenerator(
     ShortcutUtils.isDeterministicThroughProgram(
       node,
       CodeGenUtils.getExprsFromProgramOrNull(rexProgram))
+
+  override def visitNodeAndFieldIndex(
+      nodeAndFieldIndex: RexNodeAndFieldIndex): GeneratedExpression = {
+    throw new CodeGenException("RexNodeAndFieldIndex are not supported yet.")
+  }
 }
diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/logical/RemoteCalcSplitRule.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/logical/RemoteCalcSplitRule.scala
index 26baa44f43d82..9530871e43ddd 100644
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/logical/RemoteCalcSplitRule.scala
+++ b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/rules/logical/RemoteCalcSplitRule.scala
@@ -18,12 +18,13 @@
 package org.apache.flink.table.planner.plan.rules.logical
 
 import org.apache.flink.table.functions.ScalarFunction
+import org.apache.flink.table.planner.codegen.CodeGenException
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalCalc
 import org.apache.flink.table.planner.plan.utils.{InputRefVisitor, RexDefaultVisitor}
 
 import org.apache.calcite.plan.{RelOptRule, RelOptRuleCall}
 import org.apache.calcite.plan.RelOptRule.{any, operand}
-import org.apache.calcite.rex.{RexBuilder, RexCall, RexCorrelVariable, RexFieldAccess, RexInputRef, RexLocalRef, RexNode, RexProgram}
+import org.apache.calcite.rex.{RexBuilder, RexCall, RexCorrelVariable, RexFieldAccess, RexInputRef, RexLocalRef, RexNode, RexNodeAndFieldIndex, RexProgram}
 import org.apache.calcite.sql.validate.SqlValidatorUtil
 
 import java.util.function.Function
@@ -498,6 +499,10 @@ class ScalarFunctionSplitter(
       new RexInputRef(fieldsRexCall(rexCallIndex), remoteCall.getType),
       node.getField.getIndex)
   }
+
+  override def visitNodeAndFieldIndex(nodeAndFieldIndex: RexNodeAndFieldIndex): RexNode = {
+    throw new CodeGenException("RexNodeAndFieldIndex are not supported yet.")
+  }
 }
 
 /**
@@ -546,4 +551,8 @@ private class ExtractedFunctionInputRewriter(
   }
 
   override def visitNode(rexNode: RexNode): RexNode = rexNode
+
+  override def visitNodeAndFieldIndex(nodeAndFieldIndex: RexNodeAndFieldIndex): RexNode = {
+    throw new CodeGenException("RexNodeAndFieldIndex are not supported yet.")
+  }
 }
diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/MatchUtil.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/MatchUtil.scala
index 0c1760e851020..6486114115d43 100644
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/MatchUtil.scala
+++ b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/MatchUtil.scala
@@ -18,13 +18,14 @@
 package org.apache.flink.table.planner.plan.utils
 
 import org.apache.flink.table.api.ValidationException
+import org.apache.flink.table.planner.codegen.CodeGenException
 import org.apache.flink.table.planner.codegen.MatchCodeGenerator.ALL_PATTERN_VARIABLE
 import org.apache.flink.table.planner.functions.sql.FlinkSqlOperatorTable
 import org.apache.flink.table.planner.plan.logical.MatchRecognize
 import org.apache.flink.table.planner.plan.nodes.exec.spec.{MatchSpec, PartitionSpec}
 
 import _root_.scala.collection.JavaConversions._
-import org.apache.calcite.rex.{RexCall, RexNode, RexPatternFieldRef}
+import org.apache.calcite.rex.{RexCall, RexNode, RexNodeAndFieldIndex, RexPatternFieldRef}
 import org.apache.calcite.sql.fun.SqlStdOperatorTable
 
 object MatchUtil {
@@ -57,6 +58,10 @@ object MatchUtil {
     }
 
     override def visitNode(rexNode: RexNode): Option[String] = None
+
+    override def visitNodeAndFieldIndex(nodeAndFieldIndex: RexNodeAndFieldIndex): Option[String] = {
+      throw new CodeGenException("RexNodeAndFieldIndex are not supported yet.")
+    }
   }
 
   /** Convert [[MatchRecognize]] to [[MatchSpec]]. */
diff --git a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/RexNodeExtractor.scala b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/RexNodeExtractor.scala
index 4e2d1d662053f..40029d6c6064a 100644
--- a/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/RexNodeExtractor.scala
+++ b/flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/planner/plan/utils/RexNodeExtractor.scala
@@ -27,6 +27,7 @@ import org.apache.flink.table.expressions.ApiExpressionUtils._
 import org.apache.flink.table.functions.{BuiltInFunctionDefinition, FunctionIdentifier}
 import org.apache.flink.table.functions.BuiltInFunctionDefinitions.{AND, CAST, OR, TRY_CAST}
 import org.apache.flink.table.planner.calcite.FlinkTypeFactory
+import org.apache.flink.table.planner.codegen.CodeGenException
 import org.apache.flink.table.planner.functions.sql.FlinkSqlOperatorTable
 import org.apache.flink.table.planner.utils.Logging
 import org.apache.flink.table.planner.utils.TimestampStringUtils.toLocalDateTime
@@ -621,4 +622,8 @@ class RexNodeToExpressionConverter(
     str.replaceAll("\\s|_", "")
   }
 
+  override def visitNodeAndFieldIndex(
+      nodeAndFieldIndex: RexNodeAndFieldIndex): Option[ResolvedExpression] = {
+    throw new CodeGenException("RexNodeAndFieldIndex are not supported yet.")
+  }
 }
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ValuesTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ValuesTest.xml
index 089c876dea6c0..fd253c2ec8793 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ValuesTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/ValuesTest.xml
@@ -25,9 +25,9 @@ limitations under the License.
 LogicalProject(a=[$0], b=[$1]), rowType=[RecordType(INTEGER a, DECIMAL(20, 1) b)]
 +- LogicalProject(a=[$0], b=[$1]), rowType=[RecordType(INTEGER a, DECIMAL(20, 1) b)]
    +- LogicalUnion(all=[true]), rowType=[RecordType(INTEGER EXPR$0, DECIMAL(20, 1) EXPR$1)]
-      :- LogicalProject(EXPR$0=[1], EXPR$1=[2.0:DECIMAL(2, 1)]), rowType=[RecordType(INTEGER EXPR$0, DECIMAL(2, 1) EXPR$1)]
+      :- LogicalProject(EXPR$0=[1], EXPR$1=[2.0:DECIMAL(20, 1)]), rowType=[RecordType(INTEGER EXPR$0, DECIMAL(20, 1) EXPR$1)]
       :  +- LogicalValues(tuples=[[{ 0 }]]), rowType=[RecordType(INTEGER ZERO)]
-      +- LogicalProject(EXPR$0=[3], EXPR$1=[4:BIGINT]), rowType=[RecordType(INTEGER EXPR$0, BIGINT EXPR$1)]
+      +- LogicalProject(EXPR$0=[3], EXPR$1=[4.0:DECIMAL(20, 1)]), rowType=[RecordType(INTEGER EXPR$0, DECIMAL(20, 1) EXPR$1)]
          +- LogicalValues(tuples=[[{ 0 }]]), rowType=[RecordType(INTEGER ZERO)]
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/agg/GroupingSetsTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/agg/GroupingSetsTest.xml
index ae9e14592854d..af6bc3c4d935c 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/agg/GroupingSetsTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/agg/GroupingSetsTest.xml
@@ -182,10 +182,9 @@ LogicalUnion(all=[true])
 :  +- LogicalAggregate(group=[{0}], groups=[[{0}, {}]], c=[COUNT()])
 :     +- LogicalProject(deptno=[$7])
 :        +- LogicalTableScan(table=[[default_catalog, default_database, scott_emp]])
-+- LogicalProject(deptno=[$0], g=[1:BIGINT], c=[$1])
-   +- LogicalAggregate(group=[{0}], groups=[[{}]], c=[COUNT()])
-      +- LogicalProject(deptno=[$7])
-         +- LogicalTableScan(table=[[default_catalog, default_database, scott_emp]])
++- LogicalProject(deptno=[null:INTEGER], g=[1:BIGINT], c=[$0])
+   +- LogicalAggregate(group=[{}], c=[COUNT()])
+      +- LogicalTableScan(table=[[default_catalog, default_database, scott_emp]])
 ]]>
     </Resource>
     <Resource name="optimized exec plan">
@@ -196,13 +195,14 @@ Union(all=[true], union=[deptno, g, c])
 :     +- Exchange(distribution=[hash[deptno, $e]])
 :        +- LocalHashAggregate(groupBy=[deptno, $e], select=[deptno, $e, Partial_COUNT(*) AS count1$0])
 :           +- Expand(projects=[{deptno, 0 AS $e}, {null AS deptno, 1 AS $e}])
-:              +- Calc(select=[deptno])(reuse_id=[1])
-:                 +- TableSourceScan(table=[[default_catalog, default_database, scott_emp]], fields=[empno, ename, job, mgr, hiredate, sal, comm, deptno])
-+- Calc(select=[deptno, 1 AS g, c])
-   +- HashAggregate(isMerge=[true], groupBy=[deptno], select=[deptno, Final_COUNT(count1$0) AS c])
-      +- Exchange(distribution=[hash[deptno]])
-         +- LocalHashAggregate(groupBy=[deptno], select=[deptno, Partial_COUNT(*) AS count1$0])
-            +- Reused(reference_id=[1])
+:              +- Calc(select=[deptno])
+:                 +- TableSourceScan(table=[[default_catalog, default_database, scott_emp]], fields=[empno, ename, job, mgr, hiredate, sal, comm, deptno])(reuse_id=[1])
++- Calc(select=[null:INTEGER AS deptno, 1 AS g, c])
+   +- HashAggregate(isMerge=[true], select=[Final_COUNT(count1$0) AS c])
+      +- Exchange(distribution=[single])
+         +- LocalHashAggregate(select=[Partial_COUNT(*) AS count1$0])
+            +- Calc(select=[0 AS $f0])
+               +- Reused(reference_id=[1])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/BroadcastHashJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/BroadcastHashJoinTest.xml
index dc0d9c3e721b3..1a38b9d05e958 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/BroadcastHashJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/BroadcastHashJoinTest.xml
@@ -472,7 +472,7 @@ Calc(select=[d, e, f])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(d=[$3], e=[$4], f=[$5])
-+- LogicalFilter(condition=[=($3, null)])
++- LogicalFilter(condition=[false])
    +- LogicalJoin(condition=[=($0, $3)], joinType=[left])
       :- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/NestedLoopJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/NestedLoopJoinTest.xml
index 4f6c8e1e9a445..8ce9c14a3141b 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/NestedLoopJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/NestedLoopJoinTest.xml
@@ -788,7 +788,7 @@ Calc(select=[d, e, f])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(d=[$3], e=[$4], f=[$5])
-+- LogicalFilter(condition=[=($3, null)])
++- LogicalFilter(condition=[false])
    +- LogicalJoin(condition=[=($0, $3)], joinType=[left])
       :- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
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 1a1470c714680..c6e835b02edd8 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
@@ -586,7 +586,7 @@ Calc(select=[d, e, f])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(d=[$3], e=[$4], f=[$5])
-+- LogicalFilter(condition=[=($3, null)])
++- LogicalFilter(condition=[false])
    +- LogicalJoin(condition=[=($0, $3)], joinType=[left])
       :- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.xml
index b125f43544167..44ad033e09eb3 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/batch/sql/join/SortMergeJoinTest.xml
@@ -586,7 +586,7 @@ Calc(select=[d, e, f])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(d=[$3], e=[$4], f=[$5])
-+- LogicalFilter(condition=[=($3, null)])
++- LogicalFilter(condition=[false])
    +- LogicalJoin(condition=[=($0, $3)], joinType=[left])
       :- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/DecomposeGroupingSetsRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/DecomposeGroupingSetsRuleTest.xml
index b7763815535ce..5c8620535ae66 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/DecomposeGroupingSetsRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/DecomposeGroupingSetsRuleTest.xml
@@ -29,10 +29,9 @@ LogicalUnion(all=[true])
 :  +- LogicalAggregate(group=[{0}], groups=[[{0}, {}]], c=[COUNT()])
 :     +- LogicalProject(a=[$0])
 :        +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
-+- LogicalProject(a=[$0], g=[1:BIGINT], c=[$1])
-   +- LogicalAggregate(group=[{0}], groups=[[{}]], c=[COUNT()])
-      +- LogicalProject(a=[$0])
-         +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
++- LogicalProject(a=[null:INTEGER], g=[1:BIGINT], c=[$0])
+   +- LogicalAggregate(group=[{}], c=[COUNT()])
+      +- LogicalTableScan(table=[[default_catalog, default_database, MyTable]])
 ]]>
     </Resource>
     <Resource name="optimized rel plan">
@@ -43,9 +42,9 @@ FlinkLogicalUnion(all=[true])
 :     +- FlinkLogicalExpand(projects=[{a, 0 AS $e}, {null AS a, 1 AS $e}])
 :        +- FlinkLogicalCalc(select=[a])
 :           +- FlinkLogicalTableSourceScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c])
-+- FlinkLogicalCalc(select=[a, 1 AS g, c])
-   +- FlinkLogicalAggregate(group=[{0}], groups=[[{}]], c=[COUNT()])
-      +- FlinkLogicalCalc(select=[a])
++- FlinkLogicalCalc(select=[null:INTEGER AS a, 1 AS g, c])
+   +- FlinkLogicalAggregate(group=[{}], c=[COUNT()])
+      +- FlinkLogicalCalc(select=[0 AS $f0])
          +- FlinkLogicalTableSourceScan(table=[[default_catalog, default_database, MyTable]], fields=[a, b, c])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/FlinkFilterJoinRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/FlinkFilterJoinRuleTest.xml
index 9d2ed41f76409..3850d355889a7 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/FlinkFilterJoinRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/FlinkFilterJoinRuleTest.xml
@@ -563,7 +563,7 @@ LogicalProject(a1=[$0], b1=[$1], c1=[$2], b2=[$3], c2=[$4], a2=[$5])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(a1=[$0], b1=[$1], c1=[$2], b2=[$3], c2=[$4], a2=[$5])
-+- LogicalFilter(condition=[=($5, null)])
++- LogicalFilter(condition=[false])
    +- LogicalJoin(condition=[=($0, $5)], joinType=[inner])
       :- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
@@ -1054,7 +1054,7 @@ LogicalProject(a1=[$0], b1=[$1], c1=[$2], b2=[$3], c2=[$4], a2=[$5])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(a1=[$0], b1=[$1], c1=[$2], b2=[$3], c2=[$4], a2=[$5])
-+- LogicalFilter(condition=[=($5, null)])
++- LogicalFilter(condition=[false])
    +- LogicalJoin(condition=[=($0, $5)], joinType=[left])
       :- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
       +- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/RemoveSingleAggregateRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/RemoveSingleAggregateRuleTest.xml
index 11e9a158b070e..31c238f0afb84 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/RemoveSingleAggregateRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/RemoveSingleAggregateRuleTest.xml
@@ -35,15 +35,21 @@ LogicalProject(EXPR$0=[-($0, 1)])
     <Resource name="optimized rel plan">
       <![CDATA[
 Calc(select=[-(CASE(IS NULL($f1), 0, $f1), 1) AS EXPR$0])
-+- HashJoin(joinType=[LeftOuterJoin], where=[=(i, y)], select=[i, y, $f1], build=[right])
++- HashJoin(joinType=[LeftOuterJoin], where=[IS NOT DISTINCT FROM(i, y)], select=[i, y, $f1], build=[right])
    :- Exchange(distribution=[hash[i]])
    :  +- Calc(select=[i])
    :     +- TableSourceScan(table=[[default_catalog, default_database, bar]], fields=[i, s])
-   +- HashAggregate(isMerge=[true], groupBy=[y], select=[y, Final_COUNT(count$0) AS $f1])
-      +- Exchange(distribution=[hash[y]])
-         +- LocalHashAggregate(groupBy=[y], select=[y, Partial_COUNT(x) AS count$0])
-            +- Calc(select=[x, y], where=[IS NOT NULL(y)])
-               +- TableSourceScan(table=[[default_catalog, default_database, foo]], fields=[x, y])
+   +- Calc(select=[i AS y, CASE(IS NOT NULL($f1), $f1, 0) AS $f1])
+      +- HashJoin(joinType=[LeftOuterJoin], where=[IS NOT DISTINCT FROM(i, y)], select=[i, y, $f1], build=[left])
+         :- HashAggregate(isMerge=[true], groupBy=[i], select=[i])
+         :  +- Exchange(distribution=[hash[i]])
+         :     +- LocalHashAggregate(groupBy=[i], select=[i])
+         :        +- TableSourceScan(table=[[default_catalog, default_database, bar]], fields=[i, s])
+         +- HashAggregate(isMerge=[true], groupBy=[y], select=[y, Final_COUNT(count$0) AS $f1])
+            +- Exchange(distribution=[hash[y]])
+               +- LocalHashAggregate(groupBy=[y], select=[y, Partial_COUNT(x) AS count$0])
+                  +- Calc(select=[x, y], where=[IS NOT NULL(y)])
+                     +- TableSourceScan(table=[[default_catalog, default_database, foo]], fields=[x, y])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyFilterConditionRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyFilterConditionRuleTest.xml
index c32350b43b61b..466f054085fa2 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyFilterConditionRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyFilterConditionRuleTest.xml
@@ -179,10 +179,10 @@ LogicalProject(a=[$0], b=[$1], c=[$2])
     <Resource name="ast">
       <![CDATA[
 LogicalProject(a=[$0], b=[$1], c=[$2])
-+- LogicalFilter(condition=[AND(EXISTS({
++- LogicalFilter(condition=[EXISTS({
 LogicalFilter(condition=[OR(AND(=($0, 1), =($1, 2)), AND(NOT(<>($0, 1)), =($1, 3)))])
   LogicalTableScan(table=[[default_catalog, default_database, y]])
-}), true)])
+})])
    +- LogicalTableScan(table=[[default_catalog, default_database, x]])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyJoinConditionRuleTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyJoinConditionRuleTest.xml
index ec5e4f7f1516e..1ec0eaf18bbb4 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyJoinConditionRuleTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/SimplifyJoinConditionRuleTest.xml
@@ -59,15 +59,19 @@ LogicalAggregate(group=[{}], EXPR$0=[COUNT()])
       <![CDATA[
 LogicalProject(a=[$0])
 +- LogicalFilter(condition=[=($1, CASE(IS NULL($5), 0:BIGINT, $5))])
-   +- LogicalJoin(condition=[AND(=($0, $3), IS NOT DISTINCT FROM($1, $4))], joinType=[left])
+   +- LogicalJoin(condition=[AND(IS NOT DISTINCT FROM($0, $3), IS NOT DISTINCT FROM($1, $4))], joinType=[left])
       :- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
-      +- LogicalAggregate(group=[{0, 1}], EXPR$0=[COUNT()])
-         +- LogicalProject(a=[$3], b=[$4])
-            +- LogicalJoin(condition=[AND(=($0, $3), OR(<($0, 2), =($4, 5)))], joinType=[inner])
-               :- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
-               +- LogicalAggregate(group=[{0, 1}])
-                  +- LogicalProject(a=[$0], b=[$1])
-                     +- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
+      +- LogicalProject(a=[$0], b=[$1], EXPR$0=[CASE(IS NOT NULL($4), $4, 0)])
+         +- LogicalJoin(condition=[AND(IS NOT DISTINCT FROM($0, $2), IS NOT DISTINCT FROM($1, $3))], joinType=[left])
+            :- LogicalAggregate(group=[{0, 1}])
+            :  +- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
+            +- LogicalAggregate(group=[{0, 1}], EXPR$0=[COUNT()])
+               +- LogicalProject(a=[$3], b=[$4])
+                  +- LogicalJoin(condition=[AND(=($0, $3), OR(<($0, 2), =($4, 5)))], joinType=[inner])
+                     :- LogicalTableScan(table=[[default_catalog, default_database, MyTable2]])
+                     +- LogicalAggregate(group=[{0, 1}])
+                        +- LogicalProject(a=[$0], b=[$1])
+                           +- LogicalTableScan(table=[[default_catalog, default_database, MyTable1]])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.xml
index 0e9221a7d8541..5ee0b2fc55d14 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQueryAntiJoinTest.xml
@@ -96,33 +96,41 @@ LogicalProject(c=[$2])
 +- LogicalFilter(condition=[OR(=($3, 0), AND(IS NULL($13), >=($4, $3)))])
    +- LogicalJoin(condition=[=(CASE(AND(IS NOT TRUE(OR(IS NULL($1), =($6, 0))), IS NOT NULL($10)), 1, 2), $11)], joinType=[left])
       :- LogicalJoin(condition=[AND(=($0, $9), =($1, $8))], joinType=[left])
-      :  :- LogicalJoin(condition=[=($0, $5)], joinType=[left])
+      :  :- LogicalJoin(condition=[IS NOT DISTINCT FROM($0, $5)], joinType=[left])
       :  :  :- LogicalJoin(condition=[true], joinType=[inner])
       :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
-      :  :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT($0, $1)])
-      :  :  :     +- LogicalProject(d=[$0], e=[$1])
+      :  :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT() FILTER $0])
+      :  :  :     +- LogicalProject($f2=[OR(IS NOT NULL($0), IS NOT NULL($1))])
       :  :  :        +- LogicalTableScan(table=[[default_catalog, default_database, r]])
-      :  :  +- LogicalAggregate(group=[{0}], c=[COUNT()], ck=[COUNT($1)])
-      :  :     +- LogicalProject(i=[$0], j=[$1])
-      :  :        +- LogicalFilter(condition=[IS NOT NULL($0)])
-      :  :           +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+      :  :  +- LogicalProject(i=[$0], c=[CASE(IS NOT NULL($2), $2, 0)], ck=[CASE(IS NOT NULL($3), $3, 0)])
+      :  :     +- LogicalJoin(condition=[IS NOT DISTINCT FROM($0, $1)], joinType=[left])
+      :  :        :- LogicalAggregate(group=[{0}])
+      :  :        :  +- LogicalJoin(condition=[true], joinType=[inner])
+      :  :        :     :- LogicalTableScan(table=[[default_catalog, default_database, l]])
+      :  :        :     +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT() FILTER $0])
+      :  :        :        +- LogicalProject($f2=[OR(IS NOT NULL($0), IS NOT NULL($1))])
+      :  :        :           +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+      :  :        +- LogicalAggregate(group=[{0}], c=[COUNT()], ck=[COUNT($1)])
+      :  :           +- LogicalProject(i=[$0], j=[$1])
+      :  :              +- LogicalFilter(condition=[IS NOT NULL($0)])
+      :  :                 +- LogicalTableScan(table=[[default_catalog, default_database, t]])
       :  +- LogicalFilter(condition=[IS NOT NULL($0)])
       :     +- LogicalProject(j=[$0], i2=[$1], $f2=[true])
       :        +- LogicalAggregate(group=[{0, 1}])
       :           +- LogicalProject(j=[$1], i2=[$0])
       :              +- LogicalFilter(condition=[IS NOT NULL($0)])
       :                 +- LogicalTableScan(table=[[default_catalog, default_database, t]])
-      +- LogicalJoin(condition=[true], joinType=[left])
-         :- LogicalJoin(condition=[true], joinType=[left])
-         :  :- LogicalFilter(condition=[=(4, $1)])
-         :  :  +- LogicalProject(d=[$0], e=[$1], $f2=[true])
-         :  :     +- LogicalAggregate(group=[{0, 1}])
-         :  :        +- LogicalProject(d=[$0], e=[$1])
-         :  :           +- LogicalTableScan(table=[[default_catalog, default_database, r]])
-         :  +- LogicalProject($f0=[true], dummy=[$0])
-         :     +- LogicalValues(tuples=[[{ true }]])
-         +- LogicalProject($f0=[true], dummy=[$0])
-            +- LogicalValues(tuples=[[{ true }]])
+      +- LogicalFilter(condition=[=(CASE(IS NULL($3), 3, IS NOT NULL($5), 4, 5), $1)])
+         +- LogicalJoin(condition=[true], joinType=[left])
+            :- LogicalJoin(condition=[true], joinType=[left])
+            :  :- LogicalProject(d=[$0], e=[$1], $f2=[true])
+            :  :  +- LogicalAggregate(group=[{0, 1}])
+            :  :     +- LogicalProject(d=[$0], e=[$1])
+            :  :        +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+            :  +- LogicalProject($f0=[true], dummy=[$0])
+            :     +- LogicalValues(tuples=[[{ true }]])
+            +- LogicalProject($f0=[true], dummy=[$0])
+               +- LogicalValues(tuples=[[{ true }]])
 ]]>
     </Resource>
   </TestCase>
@@ -901,15 +909,21 @@ LogicalProject(d=[$0], e=[$1])
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(c=[$2])
-+- LogicalFilter(condition=[OR(=($3, 0), AND(IS NULL($11), >=($4, $3)))])
-   +- LogicalJoin(condition=[=(CASE(OR(=($5, 0), AND(IS NULL($8), >=($6, $5), IS NOT NULL($1))), 3, 4), $10)], joinType=[left])
-      :- LogicalJoin(condition=[=($1, $7)], joinType=[left])
++- LogicalFilter(condition=[OR(=($3, 0), AND(IS NULL($13), >=($4, $3)))])
+   +- LogicalJoin(condition=[AND(=(CASE(IS NULL($6), 1, 2), $11), =(CASE(OR(=($7, 0), AND(IS NULL($10), >=($8, $7), IS NOT NULL($1))), 3, 4), $12))], joinType=[left])
+      :- LogicalJoin(condition=[=($1, $9)], joinType=[left])
       :  :- LogicalJoin(condition=[true], joinType=[inner])
-      :  :  :- LogicalJoin(condition=[true], joinType=[inner])
-      :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
-      :  :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT($0, $1)])
-      :  :  :     +- LogicalProject(d=[$0], e=[$1])
-      :  :  :        +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+      :  :  :- LogicalJoin(condition=[=($0, $5)], joinType=[left])
+      :  :  :  :- LogicalJoin(condition=[true], joinType=[inner])
+      :  :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
+      :  :  :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT() FILTER $0])
+      :  :  :  :     +- LogicalProject($f2=[OR(IS NOT NULL($0), IS NOT NULL($1))])
+      :  :  :  :        +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+      :  :  :  +- LogicalProject(i1=[$0], $f1=[true])
+      :  :  :     +- LogicalAggregate(group=[{0}])
+      :  :  :        +- LogicalProject(i1=[$0])
+      :  :  :           +- LogicalFilter(condition=[IS NOT NULL($0)])
+      :  :  :              +- LogicalTableScan(table=[[default_catalog, default_database, t]])
       :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT($0)])
       :  :     +- LogicalProject(m=[$1])
       :  :        +- LogicalTableScan(table=[[default_catalog, default_database, t2]])
@@ -917,17 +931,10 @@ LogicalProject(c=[$2])
       :     +- LogicalAggregate(group=[{0}])
       :        +- LogicalProject(m=[$1])
       :           +- LogicalTableScan(table=[[default_catalog, default_database, t2]])
-      +- LogicalJoin(condition=[=($0, $3)], joinType=[left])
-         :- LogicalFilter(condition=[=(2, $0)])
-         :  +- LogicalProject(d=[$0], e=[$1], $f2=[true])
-         :     +- LogicalAggregate(group=[{0, 1}])
-         :        +- LogicalProject(d=[$0], e=[$1])
-         :           +- LogicalTableScan(table=[[default_catalog, default_database, r]])
-         +- LogicalProject(i1=[$0], $f1=[true])
-            +- LogicalAggregate(group=[{0}])
-               +- LogicalProject(i1=[$0])
-                  +- LogicalFilter(condition=[IS NOT NULL($0)])
-                     +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+      +- LogicalProject(d=[$0], e=[$1], $f2=[true])
+         +- LogicalAggregate(group=[{0, 1}])
+            +- LogicalProject(d=[$0], e=[$1])
+               +- LogicalTableScan(table=[[default_catalog, default_database, r]])
 ]]>
     </Resource>
   </TestCase>
@@ -2182,16 +2189,24 @@ LogicalProject(b=[$1])
 +- LogicalFilter(condition=[OR(=($3, 0), AND(IS NULL($12), >=($4, $3)))])
    +- LogicalJoin(condition=[=(CASE(OR(=($6, 0), IS NOT TRUE(OR(IS NULL($0), IS NOT NULL($10), <($7, $6)))), 1, 2), $11)], joinType=[left])
       :- LogicalJoin(condition=[=($0, $9)], joinType=[left])
-      :  :- LogicalJoin(condition=[=($0, $5)], joinType=[left])
+      :  :- LogicalJoin(condition=[IS NOT DISTINCT FROM($0, $5)], joinType=[left])
       :  :  :- LogicalJoin(condition=[true], joinType=[inner])
       :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
       :  :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT($0)])
       :  :  :     +- LogicalProject(d=[$0])
       :  :  :        +- LogicalTableScan(table=[[default_catalog, default_database, r]])
-      :  :  +- LogicalAggregate(group=[{0}], c=[COUNT()], ck=[COUNT($1)])
-      :  :     +- LogicalProject(i1=[$0], i=[$0])
-      :  :        +- LogicalFilter(condition=[IS NOT NULL($0)])
-      :  :           +- LogicalTableScan(table=[[default_catalog, default_database, t1]])
+      :  :  +- LogicalProject(i1=[$0], c=[CASE(IS NOT NULL($2), $2, 0)], ck=[CASE(IS NOT NULL($3), $3, 0)])
+      :  :     +- LogicalJoin(condition=[IS NOT DISTINCT FROM($0, $1)], joinType=[left])
+      :  :        :- LogicalAggregate(group=[{0}])
+      :  :        :  +- LogicalJoin(condition=[true], joinType=[inner])
+      :  :        :     :- LogicalTableScan(table=[[default_catalog, default_database, l]])
+      :  :        :     +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT($0)])
+      :  :        :        +- LogicalProject(d=[$0])
+      :  :        :           +- LogicalTableScan(table=[[default_catalog, default_database, r]])
+      :  :        +- LogicalAggregate(group=[{0}], c=[COUNT()], ck=[COUNT($1)])
+      :  :           +- LogicalProject(i1=[$0], i=[$0])
+      :  :              +- LogicalFilter(condition=[IS NOT NULL($0)])
+      :  :                 +- LogicalTableScan(table=[[default_catalog, default_database, t1]])
       :  +- LogicalFilter(condition=[=($1, $0)])
       :     +- LogicalProject(i=[$0], i2=[$1], $f2=[true])
       :        +- LogicalAggregate(group=[{0, 1}])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml
index 8d81faec9ddd0..7f410f0ea78de 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/rules/logical/subquery/SubQuerySemiJoinTest.xml
@@ -35,7 +35,7 @@ LogicalFilter(condition=[=($1, $cor0.b)])
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(s=[$1])
-+- LogicalJoin(condition=[=($2, $1)], joinType=[semi])
++- LogicalJoin(condition=[=($2, $0)], joinType=[semi])
    :- LogicalAggregate(group=[{0}], s=[SUM($1)])
    :  +- LogicalProject(b=[$1], a=[$0])
    :     +- LogicalTableScan(table=[[default_catalog, default_database, x]])
@@ -1546,10 +1546,16 @@ LogicalProject(d=[$0], e=[$1])
     <Resource name="optimized rel plan">
       <![CDATA[
 LogicalProject(c=[$2])
-+- LogicalJoin(condition=[AND(=(CASE(IS NOT NULL($2), 1, 2), $7), =(CASE(AND(<>($3, 0), IS NOT NULL($6), IS NOT NULL($1)), 3, 4), $8))], joinType=[inner])
-   :- LogicalJoin(condition=[=($1, $5)], joinType=[left])
++- LogicalJoin(condition=[AND(=(CASE(IS NOT NULL($4), 1, 2), $9), =(CASE(AND(<>($5, 0), IS NOT NULL($8), IS NOT NULL($1)), 3, 4), $10))], joinType=[inner])
+   :- LogicalJoin(condition=[=($1, $7)], joinType=[left])
    :  :- LogicalJoin(condition=[true], joinType=[inner])
-   :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
+   :  :  :- LogicalJoin(condition=[=($0, $3)], joinType=[left])
+   :  :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
+   :  :  :  +- LogicalProject(i1=[$0], $f1=[true])
+   :  :  :     +- LogicalAggregate(group=[{0}])
+   :  :  :        +- LogicalProject(i1=[$0])
+   :  :  :           +- LogicalFilter(condition=[IS NOT NULL($0)])
+   :  :  :              +- LogicalTableScan(table=[[default_catalog, default_database, t]])
    :  :  +- LogicalAggregate(group=[{}], c=[COUNT()], ck=[COUNT($0)])
    :  :     +- LogicalProject(m=[$1])
    :  :        +- LogicalTableScan(table=[[default_catalog, default_database, t2]])
@@ -1557,15 +1563,9 @@ LogicalProject(c=[$2])
    :     +- LogicalAggregate(group=[{0}])
    :        +- LogicalProject(m=[$1])
    :           +- LogicalTableScan(table=[[default_catalog, default_database, t2]])
-   +- LogicalJoin(condition=[=($0, $2)], joinType=[left])
-      :- LogicalAggregate(group=[{0, 1}])
-      :  +- LogicalProject(d=[$0], e=[$1])
-      :     +- LogicalTableScan(table=[[default_catalog, default_database, r]])
-      +- LogicalProject(i1=[$0], $f1=[true])
-         +- LogicalAggregate(group=[{0}])
-            +- LogicalProject(i1=[$0])
-               +- LogicalFilter(condition=[IS NOT NULL($0)])
-                  +- LogicalTableScan(table=[[default_catalog, default_database, t]])
+   +- LogicalAggregate(group=[{0, 1}])
+      +- LogicalProject(d=[$0], e=[$1])
+         +- LogicalTableScan(table=[[default_catalog, default_database, r]])
 ]]>
     </Resource>
   </TestCase>
@@ -1612,7 +1612,7 @@ LogicalProject(d=[$1])
       <![CDATA[
 LogicalProject(s=[$1])
 +- LogicalProject(b=[$0], s=[$1], $f2=[$2])
-   +- LogicalJoin(condition=[AND(=($3, $4), =($4, $1))], joinType=[semi])
+   +- LogicalJoin(condition=[AND(=($3, $4), =($4, $0))], joinType=[semi])
       :- LogicalProject(b=[$0], s=[$1], $f2=[$2], $f20=[CAST($2):BIGINT])
       :  +- LogicalAggregate(group=[{0}], s=[SUM($1)], agg#1=[MAX($1)])
       :     +- LogicalProject(b=[$1], a=[$0])
@@ -3832,12 +3832,16 @@ LogicalProject(d=[$0])
 LogicalProject(b=[$1])
 +- LogicalJoin(condition=[=(CASE(AND(IS NOT TRUE(OR(IS NULL($0), =($4, 0))), IS NOT NULL($8)), 1, 2), $9)], joinType=[inner])
    :- LogicalJoin(condition=[=($0, $7)], joinType=[left])
-   :  :- LogicalJoin(condition=[=($0, $3)], joinType=[left])
+   :  :- LogicalJoin(condition=[IS NOT DISTINCT FROM($0, $3)], joinType=[left])
    :  :  :- LogicalTableScan(table=[[default_catalog, default_database, l]])
-   :  :  +- LogicalAggregate(group=[{0}], c=[COUNT()], ck=[COUNT($1)])
-   :  :     +- LogicalProject(i1=[$0], i=[$0])
-   :  :        +- LogicalFilter(condition=[IS NOT NULL($0)])
-   :  :           +- LogicalTableScan(table=[[default_catalog, default_database, t1]])
+   :  :  +- LogicalProject(i1=[$0], c=[CASE(IS NOT NULL($2), $2, 0)], ck=[CASE(IS NOT NULL($3), $3, 0)])
+   :  :     +- LogicalJoin(condition=[IS NOT DISTINCT FROM($0, $1)], joinType=[left])
+   :  :        :- LogicalAggregate(group=[{0}])
+   :  :        :  +- LogicalTableScan(table=[[default_catalog, default_database, l]])
+   :  :        +- LogicalAggregate(group=[{0}], c=[COUNT()], ck=[COUNT($1)])
+   :  :           +- LogicalProject(i1=[$0], i=[$0])
+   :  :              +- LogicalFilter(condition=[IS NOT NULL($0)])
+   :  :                 +- LogicalTableScan(table=[[default_catalog, default_database, t1]])
    :  +- LogicalFilter(condition=[=($1, $0)])
    :     +- LogicalProject(i=[$0], i2=[$1], $f2=[true])
    :        +- LogicalAggregate(group=[{0, 1}])
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/InsertIntoValuesTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/InsertIntoValuesTest.xml
index 716fe8fa27367..b4cf3cbfa47c5 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/InsertIntoValuesTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/InsertIntoValuesTest.xml
@@ -24,11 +24,11 @@ limitations under the License.
       <![CDATA[
 LogicalSink(table=[default_catalog.default_database.t1], fields=[EXPR$0, EXPR$1])
 +- LogicalUnion(all=[true])
-   :- LogicalProject(EXPR$0=[MAP(_UTF-16LE'a', _UTF-16LE'123':VARCHAR(6) CHARACTER SET "UTF-16LE", _UTF-16LE'b', _UTF-16LE'123456':VARCHAR(6) CHARACTER SET "UTF-16LE")], EXPR$1=[MAP(_UTF-16LE'k1', X'c0ffee':VARBINARY(3), _UTF-16LE'k2', X'babe':VARBINARY(3))])
+   :- LogicalProject(EXPR$0=[CAST(MAP(_UTF-16LE'a', _UTF-16LE'123':VARCHAR(6) CHARACTER SET "UTF-16LE", _UTF-16LE'b', _UTF-16LE'123456':VARCHAR(6) CHARACTER SET "UTF-16LE")):(VARCHAR(2147483647) CHARACTER SET "UTF-16LE", VARCHAR(2147483647) CHARACTER SET "UTF-16LE") MAP], EXPR$1=[CAST(MAP(_UTF-16LE'k1', X'c0ffee':VARBINARY(3), _UTF-16LE'k2', X'babe':VARBINARY(3))):(VARCHAR(2147483647) CHARACTER SET "UTF-16LE", VARBINARY(2147483647)) MAP])
    :  +- LogicalValues(tuples=[[{ 0 }]])
    :- LogicalProject(EXPR$0=[null:(VARCHAR(2147483647) CHARACTER SET "UTF-16LE", VARCHAR(2147483647) CHARACTER SET "UTF-16LE") MAP], EXPR$1=[null:(VARCHAR(2147483647) CHARACTER SET "UTF-16LE", VARBINARY(2147483647)) MAP])
    :  +- LogicalValues(tuples=[[{ 0 }]])
-   +- LogicalProject(EXPR$0=[MAP(_UTF-16LE'a', _UTF-16LE'1', _UTF-16LE'b', _UTF-16LE'1')], EXPR$1=[MAP(_UTF-16LE'k1', X'10':BINARY(1), _UTF-16LE'k2', X'20':BINARY(1))])
+   +- LogicalProject(EXPR$0=[CAST(MAP(_UTF-16LE'a', _UTF-16LE'1', _UTF-16LE'b', _UTF-16LE'1')):(VARCHAR(2147483647) CHARACTER SET "UTF-16LE", VARCHAR(2147483647) CHARACTER SET "UTF-16LE") MAP], EXPR$1=[CAST(MAP(_UTF-16LE'k1', X'10':BINARY(1), _UTF-16LE'k2', X'20':BINARY(1))):(VARCHAR(2147483647) CHARACTER SET "UTF-16LE", VARBINARY(2147483647)) MAP])
       +- LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/ValuesTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/ValuesTest.xml
index 42260c1b33fc6..e61d858649383 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/ValuesTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/ValuesTest.xml
@@ -25,9 +25,9 @@ limitations under the License.
 LogicalProject(a=[$0], b=[$1]), rowType=[RecordType(INTEGER a, DECIMAL(20, 1) b)]
 +- LogicalProject(a=[$0], b=[$1]), rowType=[RecordType(INTEGER a, DECIMAL(20, 1) b)]
    +- LogicalUnion(all=[true]), rowType=[RecordType(INTEGER EXPR$0, DECIMAL(20, 1) EXPR$1)]
-      :- LogicalProject(EXPR$0=[1], EXPR$1=[2.0:DECIMAL(2, 1)]), rowType=[RecordType(INTEGER EXPR$0, DECIMAL(2, 1) EXPR$1)]
+      :- LogicalProject(EXPR$0=[1], EXPR$1=[2.0:DECIMAL(20, 1)]), rowType=[RecordType(INTEGER EXPR$0, DECIMAL(20, 1) EXPR$1)]
       :  +- LogicalValues(tuples=[[{ 0 }]]), rowType=[RecordType(INTEGER ZERO)]
-      +- LogicalProject(EXPR$0=[3], EXPR$1=[4:BIGINT]), rowType=[RecordType(INTEGER EXPR$0, BIGINT EXPR$1)]
+      +- LogicalProject(EXPR$0=[3], EXPR$1=[4.0:DECIMAL(20, 1)]), rowType=[RecordType(INTEGER EXPR$0, DECIMAL(20, 1) EXPR$1)]
          +- LogicalValues(tuples=[[{ 0 }]]), rowType=[RecordType(INTEGER ZERO)]
 ]]>
     </Resource>
diff --git a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/GroupingSetsTest.xml b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/GroupingSetsTest.xml
index a5a504566af3f..a56cec435289a 100644
--- a/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/GroupingSetsTest.xml
+++ b/flink-table/flink-table-planner/src/test/resources/org/apache/flink/table/planner/plan/stream/sql/agg/GroupingSetsTest.xml
@@ -159,6 +159,42 @@ Calc(select=[deptno, c])
       +- Expand(projects=[{deptno, 0 AS $e}, {null AS deptno, 1 AS $e}])
          +- Calc(select=[deptno])
             +- TableSourceScan(table=[[default_catalog, default_database, emps]], fields=[empno, name, deptno, gender, city, empid, age, slacker, manager, joinedat])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testCALCITE1824">
+    <Resource name="sql">
+      <![CDATA[
+SELECT deptno, GROUP_ID() AS g, COUNT(*) AS c
+FROM scott_emp GROUP BY GROUPING SETS (deptno, (), ())
+      ]]>
+    </Resource>
+    <Resource name="ast">
+      <![CDATA[
+LogicalUnion(all=[true])
+:- LogicalProject(deptno=[$0], g=[0:BIGINT], c=[$1])
+:  +- LogicalAggregate(group=[{0}], groups=[[{0}, {}]], c=[COUNT()])
+:     +- LogicalProject(deptno=[$7])
+:        +- LogicalTableScan(table=[[default_catalog, default_database, scott_emp]])
++- LogicalProject(deptno=[null:INTEGER], g=[1:BIGINT], c=[$0])
+   +- LogicalAggregate(group=[{}], c=[COUNT()])
+      +- LogicalTableScan(table=[[default_catalog, default_database, scott_emp]])
+]]>
+    </Resource>
+    <Resource name="optimized exec plan">
+      <![CDATA[
+Union(all=[true], union=[deptno, g, c])
+:- Calc(select=[deptno, 0 AS g, c])
+:  +- GroupAggregate(groupBy=[deptno, $e], select=[deptno, $e, COUNT(*) AS c])
+:     +- Exchange(distribution=[hash[deptno, $e]])
+:        +- Expand(projects=[{deptno, 0 AS $e}, {null AS deptno, 1 AS $e}])
+:           +- Calc(select=[deptno])
+:              +- TableSourceScan(table=[[default_catalog, default_database, scott_emp]], fields=[empno, ename, job, mgr, hiredate, sal, comm, deptno])(reuse_id=[1])
++- Calc(select=[null:INTEGER AS deptno, 1 AS g, c])
+   +- GroupAggregate(select=[COUNT(*) AS c])
+      +- Exchange(distribution=[single])
+         +- Calc(select=[0 AS $f0])
+            +- Reused(reference_id=[1])
 ]]>
     </Resource>
   </TestCase>
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistinctRowCountTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistinctRowCountTest.scala
index 4beb3b1802ad6..0c781ca357ea6 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistinctRowCountTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdDistinctRowCountTest.scala
@@ -105,7 +105,7 @@ class FlinkRelMdDistinctRowCountTest extends FlinkRelMdHandlerTestBase {
     assertEquals(1.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(8), null))
     assertEquals(1.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(9), null))
     assertEquals(1.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(10), null))
-    assertEquals(17.13, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(11), null), 1e-2)
+    assertEquals(20.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(11), null), 1e-2)
 
     // id > 10
     val expr1 = relBuilder
@@ -124,7 +124,10 @@ class FlinkRelMdDistinctRowCountTest extends FlinkRelMdHandlerTestBase {
     assertEquals(1.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(8), expr1))
     assertEquals(1.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(9), expr1))
     assertEquals(1.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(10), expr1))
-    assertEquals(17.13, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(11), expr1), 1e-2)
+    assertEquals(
+      16.464466094067262,
+      mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(11), expr1),
+      1e-2)
 
     // age > 15 and class = 5
     val expr2 = relBuilder
@@ -146,7 +149,7 @@ class FlinkRelMdDistinctRowCountTest extends FlinkRelMdHandlerTestBase {
     assertEquals(1.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(8), expr2))
     assertEquals(1.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(9), expr2))
     assertEquals(1.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(10), expr2))
-    assertEquals(17.13, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(11), expr2), 1e-2)
+    assertEquals(1.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(11), expr2), 1e-2)
 
     assertEquals(1.0, mq.getDistinctRowCount(logicalProject, ImmutableBitSet.of(0, 1), expr2))
   }
@@ -200,7 +203,10 @@ class FlinkRelMdDistinctRowCountTest extends FlinkRelMdHandlerTestBase {
     assertEquals(1.0, mq.getDistinctRowCount(calc, ImmutableBitSet.of(8), null))
     assertEquals(1.0, mq.getDistinctRowCount(calc, ImmutableBitSet.of(9), null))
     assertEquals(1.0, mq.getDistinctRowCount(calc, ImmutableBitSet.of(10), null))
-    assertEquals(11.22, mq.getDistinctRowCount(calc, ImmutableBitSet.of(11), null), 1e-2)
+    assertEquals(
+      16.464466094067262,
+      mq.getDistinctRowCount(calc, ImmutableBitSet.of(11), null),
+      1e-2)
 
     // class = 5
     relBuilder.push(calc)
@@ -217,7 +223,10 @@ class FlinkRelMdDistinctRowCountTest extends FlinkRelMdHandlerTestBase {
     assertEquals(1.0, mq.getDistinctRowCount(calc, ImmutableBitSet.of(8), expr2))
     assertEquals(1.0, mq.getDistinctRowCount(calc, ImmutableBitSet.of(9), expr2))
     assertEquals(1.0, mq.getDistinctRowCount(calc, ImmutableBitSet.of(10), expr2))
-    assertEquals(11.22, mq.getDistinctRowCount(calc, ImmutableBitSet.of(11), expr2), 1e-2)
+    assertEquals(
+      10.257214207425065,
+      mq.getDistinctRowCount(calc, ImmutableBitSet.of(11), expr2),
+      1e-2)
   }
 
   @Test
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdPopulationSizeTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdPopulationSizeTest.scala
index 8de367956090e..12ad645c46216 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdPopulationSizeTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdPopulationSizeTest.scala
@@ -77,7 +77,7 @@ class FlinkRelMdPopulationSizeTest extends FlinkRelMdHandlerTestBase {
     assertEquals(1.0, mq.getPopulationSize(logicalProject, ImmutableBitSet.of(8)))
     assertEquals(1.0, mq.getPopulationSize(logicalProject, ImmutableBitSet.of(9)))
     assertEquals(1.0, mq.getPopulationSize(logicalProject, ImmutableBitSet.of(10)))
-    assertEquals(16.43, mq.getPopulationSize(logicalProject, ImmutableBitSet.of(11)), 1e-2)
+    assertEquals(20.0, mq.getPopulationSize(logicalProject, ImmutableBitSet.of(11)), 1e-2)
 
     assertEquals(50.0, mq.getPopulationSize(logicalProject, ImmutableBitSet.of(0, 1)))
     assertEquals(31.24, mq.getPopulationSize(logicalProject, ImmutableBitSet.of(1, 8)), 1e-2)
@@ -113,7 +113,7 @@ class FlinkRelMdPopulationSizeTest extends FlinkRelMdHandlerTestBase {
     assertEquals(1.0, mq.getPopulationSize(logicalCalc, ImmutableBitSet.of(8)))
     assertEquals(1.0, mq.getPopulationSize(logicalCalc, ImmutableBitSet.of(9)))
     assertEquals(1.0, mq.getPopulationSize(logicalCalc, ImmutableBitSet.of(10)))
-    assertEquals(11.22, mq.getPopulationSize(logicalCalc, ImmutableBitSet.of(11)), 1e-2)
+    assertEquals(20.0, mq.getPopulationSize(logicalCalc, ImmutableBitSet.of(11)), 1e-2)
 
     assertEquals(50.0, mq.getPopulationSize(logicalCalc, ImmutableBitSet.of(0, 1)))
     assertEquals(19.64, mq.getPopulationSize(logicalCalc, ImmutableBitSet.of(1, 8)), 1e-2)
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/stream/sql/agg/GroupingSetsTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/stream/sql/agg/GroupingSetsTest.scala
index 6b5c8ff9ca837..94a791d5a89d1 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/stream/sql/agg/GroupingSetsTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/plan/stream/sql/agg/GroupingSetsTest.scala
@@ -407,9 +407,7 @@ class GroupingSetsTest extends TableTestBase {
         |SELECT deptno, GROUP_ID() AS g, COUNT(*) AS c
         |FROM scott_emp GROUP BY GROUPING SETS (deptno, (), ())
       """.stripMargin
-    assertThatThrownBy(() => util.verifyExecPlan(sqlQuery))
-      .hasMessageContaining("GROUPING SETS are currently not supported")
-      .isInstanceOf[TableException]
+    util.verifyExecPlan(sqlQuery)
   }
 
   @Test
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/runtime/batch/sql/agg/GroupingSetsITCase.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/runtime/batch/sql/agg/GroupingSetsITCase.scala
index f79fb8ddbd296..d9aaae4e2790f 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/runtime/batch/sql/agg/GroupingSetsITCase.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/planner/runtime/batch/sql/agg/GroupingSetsITCase.scala
@@ -618,13 +618,12 @@ class GroupingSetsITCase extends BatchTestBase {
       "select deptno, group_id() as g, count(*) as c " +
         "from scott_emp group by grouping sets (deptno, (), ())",
       Seq(
+        // Suddenly before CALCITE-7126 it returned result different from Postgres/Oracle
         row(10, 0, 3),
-        row(10, 1, 3),
         row(20, 0, 5),
-        row(20, 1, 5),
         row(30, 0, 6),
-        row(30, 1, 6),
-        row(null, 0, 14))
+        row(null, 0, 14),
+        row(null, 1, 14))
     )
   }
 
diff --git a/flink-table/pom.xml b/flink-table/pom.xml
index c17c122c0e60a..b4d0ddd96546b 100644
--- a/flink-table/pom.xml
+++ b/flink-table/pom.xml
@@ -79,7 +79,7 @@ under the License.
 	</dependencyManagement>
 
 	<properties>
-		<calcite.version>1.40.0</calcite.version>
+		<calcite.version>1.41.0</calcite.version>
 		<janino.version>3.1.12</janino.version>
 		<guava.version>33.4.0-jre</guava.version>
 		<quartz.version>2.5.2</quartz.version>