You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by ku...@apache.org on 2019/04/02 10:28:03 UTC

[flink] 01/01: Revert "[FLINK-12076] [table-planner-blink] Add support for generating optimized logical plan for simple group aggregate on batch (#8092)"

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

kurt pushed a commit to branch revert-8092-FLINK-12076
in repository https://gitbox.apache.org/repos/asf/flink.git

commit 65d86e45357470bdbc261bec82d4f51868a0e4e7
Author: Kurt Young <yk...@gmail.com>
AuthorDate: Tue Apr 2 18:27:54 2019 +0800

    Revert "[FLINK-12076] [table-planner-blink] Add support for generating optimized logical plan for simple group aggregate on batch (#8092)"
    
    This reverts commit 7375d70d833d3aa3c87d88928f0c70fa269b13eb.
---
 .../flink/table/api/PlannerConfigOptions.java      |   10 -
 .../flink/table/expressions/ExpressionBuilder.java |   10 -
 .../flink/table/functions/AvgAggFunction.java      |   20 +-
 .../flink/table/functions/Count1AggFunction.java   |   92 --
 .../flink/table/functions/CountAggFunction.java    |   93 --
 .../functions/DeclarativeAggregateFunction.java    |    6 -
 .../flink/table/functions/MaxAggFunction.java      |  218 ----
 .../flink/table/functions/MinAggFunction.java      |  218 ----
 .../flink/table/functions/Sum0AggFunction.java     |  190 ---
 .../flink/table/functions/SumAggFunction.java      |  173 ---
 .../flink/table/functions/sql/AggSqlFunctions.java |   36 -
 .../sql/internal/SqlAuxiliaryGroupAggFunction.java |   47 -
 .../org/apache/flink/table/api/TableConfig.scala   |    2 +-
 .../flink/table/dataview/DataViewUtils.scala       |  150 ---
 .../table/plan/rules/FlinkBatchRuleSets.scala      |    2 -
 .../physical/batch/BatchExecAggRuleBase.scala      |  176 ---
 .../physical/batch/BatchExecHashAggRule.scala      |  180 ---
 .../physical/batch/BatchExecSortAggRule.scala      |  193 ----
 .../flink/table/plan/util/AggFunctionFactory.scala |  250 ----
 .../flink/table/plan/util/AggregateUtil.scala      |  498 --------
 .../flink/table/plan/util/RelExplainUtil.scala     |   31 +-
 .../plan/util/JavaUserDefinedAggFunctions.java     |  120 --
 .../table/plan/batch/sql/HashAggregateTest.xml     | 1000 ----------------
 .../table/plan/batch/sql/SortAggregateTest.xml     | 1205 --------------------
 .../plan/batch/sql/join/SingleRowJoinTest.xml      |  250 ----
 .../table/plan/batch/sql/AggregateTestBase.scala   |  202 ----
 .../table/plan/batch/sql/HashAggregateTest.scala   |   72 --
 .../table/plan/batch/sql/SortAggregateTest.scala   |   54 -
 .../flink/table/plan/batch/sql/UnionTest.scala     |    6 +-
 .../flink/table/plan/batch/sql/ValuesTest.scala    |    8 +-
 .../plan/batch/sql/join/SingleRowJoinTest.scala    |   10 +-
 .../flink/table/plan/stream/sql/UnionTest.scala    |    6 +-
 .../flink/table/plan/stream/sql/ValuesTest.scala   |    8 +-
 .../apache/flink/table/util/TableTestBase.scala    |    8 -
 34 files changed, 38 insertions(+), 5506 deletions(-)

diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/api/PlannerConfigOptions.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/api/PlannerConfigOptions.java
index 265d998..c3d1468 100644
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/api/PlannerConfigOptions.java
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/api/PlannerConfigOptions.java
@@ -39,16 +39,6 @@ public class PlannerConfigOptions {
 							"(only count RexCall node, including leaves and interior nodes). Negative number to" +
 							" use the default threshold: double of number of nodes.");
 
-	public static final ConfigOption<String> SQL_OPTIMIZER_AGG_PHASE_ENFORCER =
-			key("sql.optimizer.agg.phase.enforcer")
-					.defaultValue("NONE")
-					.withDescription("Strategy for agg phase. Only NONE, TWO_PHASE or ONE_PHASE can be set.\n" +
-							"NONE: No special enforcer for aggregate stage. Whether to choose two stage aggregate or one" +
-							" stage aggregate depends on cost. \n" +
-							"TWO_PHASE: Enforce to use two stage aggregate which has localAggregate and globalAggregate. " +
-							"NOTE: If aggregate call does not support split into two phase, still use one stage aggregate.\n" +
-							"ONE_PHASE: Enforce to use one stage aggregate which only has CompleteGlobalAggregate.");
-
 	public static final ConfigOption<Boolean> SQL_OPTIMIZER_SHUFFLE_PARTIAL_KEY_ENABLED =
 			key("sql.optimizer.shuffle.partial-key.enabled")
 					.defaultValue(false)
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/expressions/ExpressionBuilder.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/expressions/ExpressionBuilder.java
index 0e6c10c..b51e834 100644
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/expressions/ExpressionBuilder.java
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/expressions/ExpressionBuilder.java
@@ -25,10 +25,8 @@ import java.util.List;
 
 import static org.apache.flink.table.expressions.BuiltInFunctionDefinitions.DIVIDE;
 import static org.apache.flink.table.expressions.BuiltInFunctionDefinitions.EQUALS;
-import static org.apache.flink.table.expressions.BuiltInFunctionDefinitions.GREATER_THAN;
 import static org.apache.flink.table.expressions.BuiltInFunctionDefinitions.IF;
 import static org.apache.flink.table.expressions.BuiltInFunctionDefinitions.IS_NULL;
-import static org.apache.flink.table.expressions.BuiltInFunctionDefinitions.LESS_THAN;
 import static org.apache.flink.table.expressions.BuiltInFunctionDefinitions.MINUS;
 import static org.apache.flink.table.expressions.BuiltInFunctionDefinitions.PLUS;
 
@@ -80,12 +78,4 @@ public class ExpressionBuilder {
 	public static Expression equalTo(Expression input1, Expression input2) {
 		return call(EQUALS, input1, input2);
 	}
-
-	public static Expression lessThan(Expression input1, Expression input2) {
-		return call(LESS_THAN, input1, input2);
-	}
-
-	public static Expression greaterThan(Expression input1, Expression input2) {
-		return call(GREATER_THAN, input1, input2);
-	}
 }
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/AvgAggFunction.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/AvgAggFunction.java
index 70a8b8a..6c62b7a 100644
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/AvgAggFunction.java
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/AvgAggFunction.java
@@ -23,9 +23,6 @@ import org.apache.flink.api.common.typeinfo.Types;
 import org.apache.flink.table.expressions.Expression;
 import org.apache.flink.table.expressions.UnresolvedFieldReferenceExpression;
 import org.apache.flink.table.type.DecimalType;
-import org.apache.flink.table.type.InternalType;
-import org.apache.flink.table.type.InternalTypes;
-import org.apache.flink.table.type.TypeConverters;
 import org.apache.flink.table.typeutils.DecimalTypeInfo;
 
 import java.math.BigDecimal;
@@ -47,7 +44,9 @@ public abstract class AvgAggFunction extends DeclarativeAggregateFunction {
 	private UnresolvedFieldReferenceExpression sum = new UnresolvedFieldReferenceExpression("sum");
 	private UnresolvedFieldReferenceExpression count = new UnresolvedFieldReferenceExpression("count");
 
-	public abstract TypeInformation getSumType();
+	public TypeInformation getSumType() {
+		return Types.LONG;
+	}
 
 	@Override
 	public int operandCount() {
@@ -62,14 +61,6 @@ public abstract class AvgAggFunction extends DeclarativeAggregateFunction {
 	}
 
 	@Override
-	public InternalType[] getAggBufferTypes() {
-		return new InternalType[] {
-				TypeConverters.createInternalTypeFromTypeInfo(getSumType()),
-				InternalTypes.LONG
-		};
-	}
-
-	@Override
 	public Expression[] initialValuesExpressions() {
 		return new Expression[] {
 				/* sum = */ literal(0L, getSumType()),
@@ -119,11 +110,6 @@ public abstract class AvgAggFunction extends DeclarativeAggregateFunction {
 		public TypeInformation getResultType() {
 			return Types.DOUBLE;
 		}
-
-		@Override
-		public TypeInformation getSumType() {
-			return Types.LONG;
-		}
 	}
 
 	/**
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/Count1AggFunction.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/Count1AggFunction.java
deleted file mode 100644
index 1144df9..0000000
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/Count1AggFunction.java
+++ /dev/null
@@ -1,92 +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.functions;
-
-import org.apache.flink.api.common.typeinfo.TypeInformation;
-import org.apache.flink.api.common.typeinfo.Types;
-import org.apache.flink.table.expressions.Expression;
-import org.apache.flink.table.expressions.UnresolvedFieldReferenceExpression;
-import org.apache.flink.table.type.InternalType;
-import org.apache.flink.table.type.InternalTypes;
-
-import static org.apache.flink.table.expressions.ExpressionBuilder.literal;
-import static org.apache.flink.table.expressions.ExpressionBuilder.minus;
-import static org.apache.flink.table.expressions.ExpressionBuilder.plus;
-
-/**
- * This count1 aggregate function returns the count1 of values
- * which go into it like [[CountAggFunction]].
- * It differs in that null values are also counted.
- */
-public class Count1AggFunction extends DeclarativeAggregateFunction {
-	private UnresolvedFieldReferenceExpression count1 = new UnresolvedFieldReferenceExpression("count1");
-
-	@Override
-	public int operandCount() {
-		return 1;
-	}
-
-	@Override
-	public UnresolvedFieldReferenceExpression[] aggBufferAttributes() {
-		return new UnresolvedFieldReferenceExpression[] { count1 };
-	}
-
-	@Override
-	public InternalType[] getAggBufferTypes() {
-		return new InternalType[] { InternalTypes.LONG };
-	}
-
-	@Override
-	public TypeInformation getResultType() {
-		return Types.LONG;
-	}
-
-	@Override
-	public Expression[] initialValuesExpressions() {
-		return new Expression[] {
-				/* count1 = */ literal(0L, getResultType())
-		};
-	}
-
-	@Override
-	public Expression[] accumulateExpressions() {
-		return new Expression[] {
-				/* count1 = */ plus(count1, literal(1L))
-		};
-	}
-
-	@Override
-	public Expression[] retractExpressions() {
-		return new Expression[] {
-				/* count1 = */ minus(count1, literal(1L))
-		};
-	}
-
-	@Override
-	public Expression[] mergeExpressions() {
-		return new Expression[] {
-				/* count1 = */ plus(count1, mergeOperand(count1))
-		};
-	}
-
-	@Override
-	public Expression getValueExpression() {
-		return count1;
-	}
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/CountAggFunction.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/CountAggFunction.java
deleted file mode 100644
index 520ac90..0000000
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/CountAggFunction.java
+++ /dev/null
@@ -1,93 +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.functions;
-
-import org.apache.flink.api.common.typeinfo.TypeInformation;
-import org.apache.flink.api.common.typeinfo.Types;
-import org.apache.flink.table.expressions.Expression;
-import org.apache.flink.table.expressions.UnresolvedFieldReferenceExpression;
-import org.apache.flink.table.type.InternalType;
-import org.apache.flink.table.type.InternalTypes;
-
-import static org.apache.flink.table.expressions.ExpressionBuilder.ifThenElse;
-import static org.apache.flink.table.expressions.ExpressionBuilder.isNull;
-import static org.apache.flink.table.expressions.ExpressionBuilder.literal;
-import static org.apache.flink.table.expressions.ExpressionBuilder.minus;
-import static org.apache.flink.table.expressions.ExpressionBuilder.plus;
-
-/**
- * built-in count aggregate function.
- */
-public class CountAggFunction extends DeclarativeAggregateFunction {
-	private UnresolvedFieldReferenceExpression count = new UnresolvedFieldReferenceExpression("count");
-
-	@Override
-	public int operandCount() {
-		return 1;
-	}
-
-	@Override
-	public UnresolvedFieldReferenceExpression[] aggBufferAttributes() {
-		return new UnresolvedFieldReferenceExpression[] { count };
-	}
-
-	@Override
-	public InternalType[] getAggBufferTypes() {
-		return new InternalType[] { InternalTypes.LONG };
-	}
-
-	@Override
-	public TypeInformation getResultType() {
-		return Types.LONG;
-	}
-
-	@Override
-	public Expression[] initialValuesExpressions() {
-		return new Expression[] {
-				/* count = */ literal(0L, getResultType())
-		};
-	}
-
-	@Override
-	public Expression[] accumulateExpressions() {
-		return new Expression[] {
-				/* count = */ ifThenElse(isNull(operand(0)), count, plus(count, literal(1L)))
-		};
-	}
-
-	@Override
-	public Expression[] retractExpressions() {
-		return new Expression[] {
-				/* count = */ ifThenElse(isNull(operand(0)), count, minus(count, literal(1L)))
-		};
-	}
-
-	@Override
-	public Expression[] mergeExpressions() {
-		return new Expression[] {
-				/* count = */ plus(count, mergeOperand(count))
-		};
-	}
-
-	// If all input are nulls, count will be 0 and we will get result 0.
-	@Override
-	public Expression getValueExpression() {
-		return count;
-	}
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/DeclarativeAggregateFunction.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/DeclarativeAggregateFunction.java
index ae26bf9..0cd808e 100644
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/DeclarativeAggregateFunction.java
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/DeclarativeAggregateFunction.java
@@ -21,7 +21,6 @@ package org.apache.flink.table.functions;
 import org.apache.flink.api.common.typeinfo.TypeInformation;
 import org.apache.flink.table.expressions.Expression;
 import org.apache.flink.table.expressions.UnresolvedFieldReferenceExpression;
-import org.apache.flink.table.type.InternalType;
 import org.apache.flink.util.Preconditions;
 
 import java.util.Arrays;
@@ -59,11 +58,6 @@ public abstract class DeclarativeAggregateFunction extends UserDefinedFunction {
 	public abstract UnresolvedFieldReferenceExpression[] aggBufferAttributes();
 
 	/**
-	 * All types of the aggregate buffer.
-	 */
-	public abstract InternalType[] getAggBufferTypes();
-
-	/**
 	 * The result type of the function.
 	 */
 	public abstract TypeInformation getResultType();
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/MaxAggFunction.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/MaxAggFunction.java
deleted file mode 100644
index 26098ff..0000000
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/MaxAggFunction.java
+++ /dev/null
@@ -1,218 +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.functions;
-
-import org.apache.flink.api.common.typeinfo.TypeInformation;
-import org.apache.flink.api.common.typeinfo.Types;
-import org.apache.flink.table.expressions.Expression;
-import org.apache.flink.table.expressions.UnresolvedFieldReferenceExpression;
-import org.apache.flink.table.type.InternalType;
-import org.apache.flink.table.type.TypeConverters;
-import org.apache.flink.table.typeutils.DecimalTypeInfo;
-
-import static org.apache.flink.table.expressions.ExpressionBuilder.greaterThan;
-import static org.apache.flink.table.expressions.ExpressionBuilder.ifThenElse;
-import static org.apache.flink.table.expressions.ExpressionBuilder.isNull;
-import static org.apache.flink.table.expressions.ExpressionBuilder.nullOf;
-
-/**
- * built-in max aggregate function.
- */
-public abstract class MaxAggFunction extends DeclarativeAggregateFunction {
-	private UnresolvedFieldReferenceExpression max = new UnresolvedFieldReferenceExpression("max");
-
-	@Override
-	public int operandCount() {
-		return 1;
-	}
-
-	@Override
-	public UnresolvedFieldReferenceExpression[] aggBufferAttributes() {
-		return new UnresolvedFieldReferenceExpression[] { max };
-	}
-
-	@Override
-	public InternalType[] getAggBufferTypes() {
-		return new InternalType[] { TypeConverters.createInternalTypeFromTypeInfo(getResultType()) };
-	}
-
-	@Override
-	public Expression[] initialValuesExpressions() {
-		return new Expression[] {
-				/* max = */ nullOf(getResultType())
-		};
-	}
-
-	@Override
-	public Expression[] accumulateExpressions() {
-		return new Expression[] {
-				/* max = */
-				ifThenElse(isNull(operand(0)), max,
-						ifThenElse(isNull(max), operand(0),
-								ifThenElse(greaterThan(operand(0), max), operand(0), max)))
-		};
-	}
-
-	@Override
-	public Expression[] retractExpressions() {
-		return new Expression[] {};
-	}
-
-	@Override
-	public Expression[] mergeExpressions() {
-		return new Expression[] {
-				/* max = */
-				ifThenElse(isNull(mergeOperand(max)), max,
-						ifThenElse(isNull(max), mergeOperand(max),
-								ifThenElse(greaterThan(mergeOperand(max), max), mergeOperand(max), max)))
-		};
-	}
-
-	@Override
-	public Expression getValueExpression() {
-		return max;
-	}
-
-	/**
-	 * Built-in Int Max aggregate function.
-	 */
-	public static class IntMaxAggFunction extends MaxAggFunction {
-
-		@Override
-		public TypeInformation getResultType() {
-			return Types.INT;
-		}
-	}
-
-	/**
-	 * Built-in Byte Max aggregate function.
-	 */
-	public static class ByteMaxAggFunction extends MaxAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.BYTE;
-		}
-	}
-
-	/**
-	 * Built-in Short Max aggregate function.
-	 */
-	public static class ShortMaxAggFunction extends MaxAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.SHORT;
-		}
-	}
-
-	/**
-	 * Built-in Long Max aggregate function.
-	 */
-	public static class LongMaxAggFunction extends MaxAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.LONG;
-		}
-	}
-
-	/**
-	 * Built-in Float Max aggregate function.
-	 */
-	public static class FloatMaxAggFunction extends MaxAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.FLOAT;
-		}
-	}
-
-	/**
-	 * Built-in Double Max aggregate function.
-	 */
-	public static class DoubleMaxAggFunction extends MaxAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.DOUBLE;
-		}
-	}
-
-	/**
-	 * Built-in Decimal Max aggregate function.
-	 */
-	public static class DecimalMaxAggFunction extends MaxAggFunction {
-		private DecimalTypeInfo decimalType;
-
-		public DecimalMaxAggFunction(DecimalTypeInfo decimalType) {
-			this.decimalType = decimalType;
-		}
-
-		@Override
-		public TypeInformation getResultType() {
-			return decimalType;
-		}
-	}
-
-	/**
-	 * Built-in Boolean Max aggregate function.
-	 */
-	public static class BooleanMaxAggFunction extends MaxAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.BOOLEAN;
-		}
-	}
-
-	/**
-	 * Built-in String Max aggregate function.
-	 */
-	public static class StringMaxAggFunction extends MaxAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.STRING;
-		}
-	}
-
-	/**
-	 * Built-in Date Max aggregate function.
-	 */
-	public static class DateMaxAggFunction extends MaxAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.SQL_DATE;
-		}
-	}
-
-	/**
-	 * Built-in Time Max aggregate function.
-	 */
-	public static class TimeMaxAggFunction extends MaxAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.SQL_TIME;
-		}
-	}
-
-	/**
-	 * Built-in Timestamp Max aggregate function.
-	 */
-	public static class TimestampMaxAggFunction extends MaxAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.SQL_TIMESTAMP;
-		}
-	}
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/MinAggFunction.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/MinAggFunction.java
deleted file mode 100644
index 701690a..0000000
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/MinAggFunction.java
+++ /dev/null
@@ -1,218 +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.functions;
-
-import org.apache.flink.api.common.typeinfo.TypeInformation;
-import org.apache.flink.api.common.typeinfo.Types;
-import org.apache.flink.table.expressions.Expression;
-import org.apache.flink.table.expressions.UnresolvedFieldReferenceExpression;
-import org.apache.flink.table.type.InternalType;
-import org.apache.flink.table.type.TypeConverters;
-import org.apache.flink.table.typeutils.DecimalTypeInfo;
-
-import static org.apache.flink.table.expressions.ExpressionBuilder.ifThenElse;
-import static org.apache.flink.table.expressions.ExpressionBuilder.isNull;
-import static org.apache.flink.table.expressions.ExpressionBuilder.lessThan;
-import static org.apache.flink.table.expressions.ExpressionBuilder.nullOf;
-
-/**
- * built-in min aggregate function.
- */
-public abstract class MinAggFunction extends DeclarativeAggregateFunction {
-	private UnresolvedFieldReferenceExpression min = new UnresolvedFieldReferenceExpression("min");
-
-	@Override
-	public int operandCount() {
-		return 1;
-	}
-
-	@Override
-	public UnresolvedFieldReferenceExpression[] aggBufferAttributes() {
-		return new UnresolvedFieldReferenceExpression[] { min };
-	}
-
-	@Override
-	public InternalType[] getAggBufferTypes() {
-		return new InternalType[] { TypeConverters.createInternalTypeFromTypeInfo(getResultType()) };
-	}
-
-	@Override
-	public Expression[] initialValuesExpressions() {
-		return new Expression[] {
-				/* min = */ nullOf(getResultType())
-		};
-	}
-
-	@Override
-	public Expression[] accumulateExpressions() {
-		return new Expression[] {
-				/* min = */
-				ifThenElse(isNull(operand(0)), min,
-						ifThenElse(isNull(min), operand(0),
-								ifThenElse(lessThan(operand(0), min), operand(0), min)))
-		};
-	}
-
-	@Override
-	public Expression[] retractExpressions() {
-		return new Expression[] {};
-	}
-
-	@Override
-	public Expression[] mergeExpressions() {
-		return new Expression[] {
-				/* min = */
-				ifThenElse(isNull(mergeOperand(min)), min,
-						ifThenElse(isNull(min), mergeOperand(min),
-								ifThenElse(lessThan(mergeOperand(min), min), mergeOperand(min), min)))
-		};
-	}
-
-	@Override
-	public Expression getValueExpression() {
-		return min;
-	}
-
-	/**
-	 * Built-in Int Min aggregate function.
-	 */
-	public static class IntMinAggFunction extends MinAggFunction {
-
-		@Override
-		public TypeInformation getResultType() {
-			return Types.INT;
-		}
-	}
-
-	/**
-	 * Built-in Byte Min aggregate function.
-	 */
-	public static class ByteMinAggFunction extends MinAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.BYTE;
-		}
-	}
-
-	/**
-	 * Built-in Short Min aggregate function.
-	 */
-	public static class ShortMinAggFunction extends MinAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.SHORT;
-		}
-	}
-
-	/**
-	 * Built-in Long Min aggregate function.
-	 */
-	public static class LongMinAggFunction extends MinAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.LONG;
-		}
-	}
-
-	/**
-	 * Built-in Float Min aggregate function.
-	 */
-	public static class FloatMinAggFunction extends MinAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.FLOAT;
-		}
-	}
-
-	/**
-	 * Built-in Double Min aggregate function.
-	 */
-	public static class DoubleMinAggFunction extends MinAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.DOUBLE;
-		}
-	}
-
-	/**
-	 * Built-in Decimal Min aggregate function.
-	 */
-	public static class DecimalMinAggFunction extends MinAggFunction {
-		private DecimalTypeInfo decimalType;
-
-		public DecimalMinAggFunction(DecimalTypeInfo decimalType) {
-			this.decimalType = decimalType;
-		}
-
-		@Override
-		public TypeInformation getResultType() {
-			return decimalType;
-		}
-	}
-
-	/**
-	 * Built-in Boolean Min aggregate function.
-	 */
-	public static class BooleanMinAggFunction extends MinAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.BOOLEAN;
-		}
-	}
-
-	/**
-	 * Built-in String Min aggregate function.
-	 */
-	public static class StringMinAggFunction extends MinAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.STRING;
-		}
-	}
-
-	/**
-	 * Built-in Date Min aggregate function.
-	 */
-	public static class DateMinAggFunction extends MinAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.SQL_DATE;
-		}
-	}
-
-	/**
-	 * Built-in Time Min aggregate function.
-	 */
-	public static class TimeMinAggFunction extends MinAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.SQL_TIME;
-		}
-	}
-
-	/**
-	 * Built-in Timestamp Min aggregate function.
-	 */
-	public static class TimestampMinAggFunction extends MinAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.SQL_TIMESTAMP;
-		}
-	}
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/Sum0AggFunction.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/Sum0AggFunction.java
deleted file mode 100644
index 412042b..0000000
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/Sum0AggFunction.java
+++ /dev/null
@@ -1,190 +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.functions;
-
-import org.apache.flink.api.common.typeinfo.TypeInformation;
-import org.apache.flink.api.common.typeinfo.Types;
-import org.apache.flink.table.expressions.Expression;
-import org.apache.flink.table.expressions.UnresolvedFieldReferenceExpression;
-import org.apache.flink.table.type.DecimalType;
-import org.apache.flink.table.type.InternalType;
-import org.apache.flink.table.type.TypeConverters;
-import org.apache.flink.table.typeutils.DecimalTypeInfo;
-
-import java.math.BigDecimal;
-
-import static org.apache.flink.table.expressions.ExpressionBuilder.ifThenElse;
-import static org.apache.flink.table.expressions.ExpressionBuilder.isNull;
-import static org.apache.flink.table.expressions.ExpressionBuilder.literal;
-import static org.apache.flink.table.expressions.ExpressionBuilder.minus;
-import static org.apache.flink.table.expressions.ExpressionBuilder.plus;
-
-/**
- * built-in sum0 aggregate function.
- */
-public abstract class Sum0AggFunction extends DeclarativeAggregateFunction {
-	private UnresolvedFieldReferenceExpression sum0 = new UnresolvedFieldReferenceExpression("sum");
-
-	@Override
-	public int operandCount() {
-		return 1;
-	}
-
-	@Override
-	public UnresolvedFieldReferenceExpression[] aggBufferAttributes() {
-		return new UnresolvedFieldReferenceExpression[] { sum0 };
-	}
-
-	@Override
-	public InternalType[] getAggBufferTypes() {
-		return new InternalType[] { TypeConverters.createInternalTypeFromTypeInfo(getResultType()) };
-	}
-
-	@Override
-	public Expression[] initialValuesExpressions() {
-		return new Expression[] {
-				/* sum0 = */ literal(0L, getResultType())
-		};
-	}
-
-	@Override
-	public Expression[] accumulateExpressions() {
-		return new Expression[] {
-				/* sum0 = */ ifThenElse(isNull(operand(0)), sum0, plus(sum0, operand(0)))
-		};
-	}
-
-	@Override
-	public Expression[] retractExpressions() {
-		return new Expression[] {
-				/* sum0 = */ ifThenElse(isNull(operand(0)), sum0, minus(sum0, operand(0)))
-		};
-	}
-
-	@Override
-	public Expression[] mergeExpressions() {
-		return new Expression[] {
-				/* sum0 = */ plus(sum0, mergeOperand(sum0))
-		};
-	}
-
-	@Override
-	public Expression getValueExpression() {
-		return sum0;
-	}
-
-	/**
-	 * Built-in Int Sum0 aggregate function.
-	 */
-	public static class IntSum0AggFunction extends Sum0AggFunction {
-
-		@Override
-		public TypeInformation getResultType() {
-			return Types.INT;
-		}
-	}
-
-	/**
-	 * Built-in Byte Sum0 aggregate function.
-	 */
-	public static class ByteSum0AggFunction extends Sum0AggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.BYTE;
-		}
-	}
-
-	/**
-	 * Built-in Short Sum0 aggregate function.
-	 */
-	public static class ShortSum0AggFunction extends Sum0AggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.SHORT;
-		}
-	}
-
-	/**
-	 * Built-in Long Sum0 aggregate function.
-	 */
-	public static class LongSum0AggFunction extends Sum0AggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.LONG;
-		}
-	}
-
-	/**
-	 * Built-in Float Sum0 aggregate function.
-	 */
-	public static class FloatSum0AggFunction extends Sum0AggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.FLOAT;
-		}
-
-		@Override
-		public Expression[] initialValuesExpressions() {
-			return new Expression[] {
-					/* sum0 = */ literal(0.0f, getResultType())
-			};
-		}
-	}
-
-	/**
-	 * Built-in Double Sum0 aggregate function.
-	 */
-	public static class DoubleSum0AggFunction extends Sum0AggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.DOUBLE;
-		}
-
-		@Override
-		public Expression[] initialValuesExpressions() {
-			return new Expression[] {
-					/* sum0 = */ literal(0.0d, getResultType())
-			};
-		}
-	}
-
-	/**
-	 * Built-in Decimal Sum0 aggregate function.
-	 */
-	public static class DecimalSum0AggFunction extends Sum0AggFunction {
-		private DecimalTypeInfo decimalType;
-
-		public DecimalSum0AggFunction(DecimalTypeInfo decimalType) {
-			this.decimalType = decimalType;
-		}
-
-		@Override
-		public TypeInformation getResultType() {
-			DecimalType sumType = DecimalType.inferAggSumType(decimalType.scale());
-			return new DecimalTypeInfo(sumType.precision(), sumType.scale());
-		}
-
-		@Override
-		public Expression[] initialValuesExpressions() {
-			return new Expression[] {
-					/* sum0 = */ literal(new BigDecimal(0), getResultType())
-			};
-		}
-	}
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/SumAggFunction.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/SumAggFunction.java
deleted file mode 100644
index a9ab199..0000000
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/SumAggFunction.java
+++ /dev/null
@@ -1,173 +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.functions;
-
-import org.apache.flink.api.common.typeinfo.TypeInformation;
-import org.apache.flink.api.common.typeinfo.Types;
-import org.apache.flink.table.expressions.Expression;
-import org.apache.flink.table.expressions.UnresolvedFieldReferenceExpression;
-import org.apache.flink.table.type.DecimalType;
-import org.apache.flink.table.type.InternalType;
-import org.apache.flink.table.type.TypeConverters;
-import org.apache.flink.table.typeutils.DecimalTypeInfo;
-
-import static org.apache.flink.table.expressions.ExpressionBuilder.ifThenElse;
-import static org.apache.flink.table.expressions.ExpressionBuilder.isNull;
-import static org.apache.flink.table.expressions.ExpressionBuilder.minus;
-import static org.apache.flink.table.expressions.ExpressionBuilder.nullOf;
-import static org.apache.flink.table.expressions.ExpressionBuilder.plus;
-
-/**
- * built-in sum aggregate function.
- */
-public abstract class SumAggFunction extends DeclarativeAggregateFunction {
-	private UnresolvedFieldReferenceExpression sum = new UnresolvedFieldReferenceExpression("sum");
-
-	@Override
-	public int operandCount() {
-		return 1;
-	}
-
-	@Override
-	public UnresolvedFieldReferenceExpression[] aggBufferAttributes() {
-		return new UnresolvedFieldReferenceExpression[] { sum };
-	}
-
-	@Override
-	public InternalType[] getAggBufferTypes() {
-		return new InternalType[] { TypeConverters.createInternalTypeFromTypeInfo(getResultType()) };
-	}
-
-	@Override
-	public Expression[] initialValuesExpressions() {
-		return new Expression[] {
-				/* sum = */ nullOf(getResultType())
-		};
-	}
-
-	@Override
-	public Expression[] accumulateExpressions() {
-		return new Expression[] {
-				/* sum = */
-				ifThenElse(isNull(operand(0)), sum,
-						ifThenElse(isNull(sum), operand(0), plus(sum, operand(0))))
-		};
-	}
-
-	@Override
-	public Expression[] retractExpressions() {
-		return new Expression[] {
-				/* sum = */
-				ifThenElse(isNull(operand(0)), sum,
-						ifThenElse(isNull(sum), operand(0), minus(sum, operand(0))))
-		};
-	}
-
-	@Override
-	public Expression[] mergeExpressions() {
-		return new Expression[] {
-				/* sum = */
-				ifThenElse(isNull(mergeOperand(sum)), sum,
-						ifThenElse(isNull(sum), mergeOperand(sum), plus(sum, mergeOperand(sum))))
-		};
-	}
-
-	@Override
-	public Expression getValueExpression() {
-		return sum;
-	}
-
-	/**
-	 * Built-in Int Sum aggregate function.
-	 */
-	public static class IntSumAggFunction extends SumAggFunction {
-
-		@Override
-		public TypeInformation getResultType() {
-			return Types.INT;
-		}
-	}
-
-	/**
-	 * Built-in Byte Sum aggregate function.
-	 */
-	public static class ByteSumAggFunction extends SumAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.BYTE;
-		}
-	}
-
-	/**
-	 * Built-in Short Sum aggregate function.
-	 */
-	public static class ShortSumAggFunction extends SumAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.SHORT;
-		}
-	}
-
-	/**
-	 * Built-in Long Sum aggregate function.
-	 */
-	public static class LongSumAggFunction extends SumAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.LONG;
-		}
-	}
-
-	/**
-	 * Built-in Float Sum aggregate function.
-	 */
-	public static class FloatSumAggFunction extends SumAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.FLOAT;
-		}
-	}
-
-	/**
-	 * Built-in Double Sum aggregate function.
-	 */
-	public static class DoubleSumAggFunction extends SumAggFunction {
-		@Override
-		public TypeInformation getResultType() {
-			return Types.DOUBLE;
-		}
-	}
-
-	/**
-	 * Built-in Decimal Sum aggregate function.
-	 */
-	public static class DecimalSumAggFunction extends SumAggFunction {
-		private DecimalTypeInfo decimalType;
-
-		public DecimalSumAggFunction(DecimalTypeInfo decimalType) {
-			this.decimalType = decimalType;
-		}
-
-		@Override
-		public TypeInformation getResultType() {
-			DecimalType sumType = DecimalType.inferAggSumType(decimalType.scale());
-			return new DecimalTypeInfo(sumType.precision(), sumType.scale());
-		}
-	}
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/sql/AggSqlFunctions.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/sql/AggSqlFunctions.java
deleted file mode 100644
index 9474b09..0000000
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/sql/AggSqlFunctions.java
+++ /dev/null
@@ -1,36 +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.functions.sql;
-
-import org.apache.flink.table.functions.sql.internal.SqlAuxiliaryGroupAggFunction;
-
-import org.apache.calcite.sql.SqlAggFunction;
-
-/**
- * aggregate functions.
- */
-public class AggSqlFunctions {
-
-	/**
-	 * <code>AUXILIARY_GROUP</code> aggregate function.
-	 * Only be used in internally.
-	 */
-	public static final SqlAggFunction AUXILIARY_GROUP = new SqlAuxiliaryGroupAggFunction();
-
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/sql/internal/SqlAuxiliaryGroupAggFunction.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/sql/internal/SqlAuxiliaryGroupAggFunction.java
deleted file mode 100644
index 608c416..0000000
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/functions/sql/internal/SqlAuxiliaryGroupAggFunction.java
+++ /dev/null
@@ -1,47 +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.functions.sql.internal;
-
-import org.apache.flink.annotation.Internal;
-
-import org.apache.calcite.sql.SqlAggFunction;
-import org.apache.calcite.sql.SqlFunctionCategory;
-import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.type.OperandTypes;
-import org.apache.calcite.sql.type.ReturnTypes;
-
-/**
- * An internal [[SqlAggFunction]] to represents auxiliary group keys
- * which will not be computed as key and does not also affect the correctness of the final result.
- */
-@Internal
-public class SqlAuxiliaryGroupAggFunction extends SqlAggFunction {
-
-	public SqlAuxiliaryGroupAggFunction() {
-		super("AUXILIARY_GROUP",
-				null,
-				SqlKind.OTHER_FUNCTION,
-				ReturnTypes.ARG0,
-				null,
-				OperandTypes.ANY,
-				SqlFunctionCategory.SYSTEM,
-				false,
-				false);
-	}
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/api/TableConfig.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/api/TableConfig.scala
index fdad9d5..e88f587 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/api/TableConfig.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/api/TableConfig.scala
@@ -145,7 +145,6 @@ class TableConfig {
   def setCalciteConfig(calciteConfig: CalciteConfig): Unit = {
     this.calciteConfig = Preconditions.checkNotNull(calciteConfig)
   }
-
   /**
     * Returns true if given [[OperatorType]] is enabled, else false.
     */
@@ -176,3 +175,4 @@ object AggPhaseEnforcer extends Enumeration {
   type AggPhaseEnforcer = Value
   val NONE, ONE_PHASE, TWO_PHASE = Value
 }
+
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/dataview/DataViewUtils.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/dataview/DataViewUtils.scala
deleted file mode 100644
index 5086c70..0000000
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/dataview/DataViewUtils.scala
+++ /dev/null
@@ -1,150 +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.dataview
-
-import org.apache.flink.api.common.typeinfo.TypeInformation
-import org.apache.flink.api.common.typeutils.CompositeType
-import org.apache.flink.api.java.typeutils.{PojoField, PojoTypeInfo, RowTypeInfo}
-import org.apache.flink.table.`type`.{RowType, TypeConverters}
-import org.apache.flink.table.api.TableException
-import org.apache.flink.table.api.dataview._
-import org.apache.flink.table.dataformat.GenericRow
-import org.apache.flink.table.functions.AggregateFunction
-import org.apache.flink.table.typeutils._
-
-import java.util
-
-import scala.collection.mutable
-
-object DataViewUtils {
-
-  /**
-    * Use NullSerializer for StateView fields from accumulator type information.
-    *
-    * @param index index of aggregate function
-    * @param aggFun aggregate function
-    * @param externalAccType accumulator type information, only support pojo type
-    * @param isStateBackedDataViews is data views use state backend
-    * @return mapping of accumulator type information and data view config which contains id,
-    *         field name and state descriptor
-    */
-  def useNullSerializerForStateViewFieldsFromAccType(
-      index: Int,
-      aggFun: AggregateFunction[_, _],
-      externalAccType: TypeInformation[_],
-      isStateBackedDataViews: Boolean): (TypeInformation[_], Array[DataViewSpec]) = {
-
-    val acc = aggFun.createAccumulator()
-    val accumulatorSpecs = new mutable.ArrayBuffer[DataViewSpec]
-
-    externalAccType match {
-      case pojoType: PojoTypeInfo[_] if pojoType.getArity > 0 =>
-        val arity = pojoType.getArity
-        val newPojoFields = new util.ArrayList[PojoField]()
-
-        for (i <- 0 until arity) {
-          val pojoField = pojoType.getPojoFieldAt(i)
-          val field = pojoField.getField
-          val fieldName = field.getName
-          field.setAccessible(true)
-          val instance = field.get(acc)
-          val (newTypeInfo: TypeInformation[_], spec: Option[DataViewSpec]) =
-            decorateDataViewTypeInfo(
-              pojoField.getTypeInformation,
-              instance,
-              isStateBackedDataViews,
-              index,
-              i,
-              fieldName)
-
-          newPojoFields.add(new PojoField(field, newTypeInfo))
-          if (spec.isDefined) {
-            accumulatorSpecs += spec.get
-          }
-        }
-        val pojoTypeInfo = new PojoTypeInfo(externalAccType.getTypeClass, newPojoFields)
-        (pojoTypeInfo, accumulatorSpecs.toArray)
-
-      // RowType's ExternalTypeInfo is RowTypeInfo
-      // so we add another check => acc.isInstanceOf[GenericRow]
-      case r: RowTypeInfo if acc.isInstanceOf[GenericRow] =>
-        val accInstance = acc.asInstanceOf[GenericRow]
-        val (arity, fieldNames, fieldTypes) = (r.getArity, r.getFieldNames, r.getFieldTypes)
-        val newFieldTypes = for (i <- 0 until arity) yield {
-          val fieldName = fieldNames(i)
-          val fieldInstance = accInstance.getField(i)
-          val (newTypeInfo: TypeInformation[_], spec: Option[DataViewSpec]) =
-            decorateDataViewTypeInfo(
-              fieldTypes(i),
-              fieldInstance,
-              isStateBackedDataViews,
-              index,
-              i,
-              fieldName)
-          if (spec.isDefined) {
-            accumulatorSpecs += spec.get
-          }
-          TypeConverters.createInternalTypeFromTypeInfo(newTypeInfo)
-        }
-
-        val newType = new RowType(newFieldTypes.toArray, fieldNames)
-        (TypeConverters.createExternalTypeInfoFromInternalType(newType), accumulatorSpecs.toArray)
-      case ct: CompositeType[_] if includesDataView(ct) =>
-        throw new TableException(
-          "MapView, SortedMapView and ListView only supported in accumulators of POJO type.")
-      case _ => (externalAccType, Array.empty)
-    }
-  }
-
-  /** Recursively checks if composite type includes a data view type. */
-  def includesDataView(ct: CompositeType[_]): Boolean = {
-    (0 until ct.getArity).exists(i =>
-      ct.getTypeAt(i) match {
-        case nestedCT: CompositeType[_] => includesDataView(nestedCT)
-        case t: TypeInformation[_] if t.getTypeClass == classOf[ListView[_]] => true
-        case t: TypeInformation[_] if t.getTypeClass == classOf[MapView[_, _]] => true
-        // TODO supports SortedMapView
-        // case t: TypeInformation[_] if t.getTypeClass == classOf[SortedMapView[_, _]] => true
-        case _ => false
-      }
-    )
-  }
-
-  /** Analyse dataview element types and decorate the dataview typeinfos */
-  def decorateDataViewTypeInfo(
-      info: TypeInformation[_],
-      instance: AnyRef,
-      isStateBackedDataViews: Boolean,
-      aggIndex: Int,
-      fieldIndex: Int,
-      fieldName: String): (TypeInformation[_], Option[DataViewSpec]) = {
-    var spec: Option[DataViewSpec] = None
-    val resultTypeInfo: TypeInformation[_] = info match {
-      case ct: CompositeType[_] if includesDataView(ct) =>
-        throw new TableException(
-          "MapView, SortedMapView and ListView only supported at first level of " +
-            "accumulators of Pojo type.")
-      // TODO supports MapViewTypeInfo, SortedMapViewTypeInfo, ListViewTypeInfo
-
-      case t: TypeInformation[_] => t
-    }
-
-    (resultTypeInfo, spec)
-  }
-
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/FlinkBatchRuleSets.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/FlinkBatchRuleSets.scala
index 58cfc1a..01ceb41 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/FlinkBatchRuleSets.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/FlinkBatchRuleSets.scala
@@ -222,8 +222,6 @@ object FlinkBatchRuleSets {
     BatchExecLimitRule.INSTANCE,
     BatchExecSortLimitRule.INSTANCE,
     BatchExecRankRule.INSTANCE,
-    BatchExecHashAggRule.INSTANCE,
-    BatchExecSortAggRule.INSTANCE,
     BatchExecHashJoinRule.INSTANCE,
     BatchExecSortMergeJoinRule.INSTANCE,
     BatchExecNestedLoopJoinRule.INSTANCE,
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/physical/batch/BatchExecAggRuleBase.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/physical/batch/BatchExecAggRuleBase.scala
deleted file mode 100644
index 79c1fed..0000000
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/physical/batch/BatchExecAggRuleBase.scala
+++ /dev/null
@@ -1,176 +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.plan.rules.physical.batch
-
-import org.apache.flink.table.JArrayList
-import org.apache.flink.table.`type`.{InternalType, TypeConverters}
-import org.apache.flink.table.api.{AggPhaseEnforcer, PlannerConfigOptions, TableConfig, TableException}
-import org.apache.flink.table.calcite.FlinkTypeFactory
-import org.apache.flink.table.dataformat.BinaryRow
-import org.apache.flink.table.functions.utils.UserDefinedFunctionUtils._
-import org.apache.flink.table.functions.{AggregateFunction, DeclarativeAggregateFunction, UserDefinedFunction}
-import org.apache.flink.table.plan.util.{AggregateUtil, RelFieldCollationUtil}
-
-import org.apache.calcite.rel.`type`.RelDataType
-import org.apache.calcite.rel.core.Aggregate
-import org.apache.calcite.rel.{RelCollation, RelCollations, RelFieldCollation}
-import org.apache.calcite.util.Util
-
-import scala.collection.JavaConversions._
-
-trait BatchExecAggRuleBase {
-
-  protected def inferLocalAggType(
-      inputRowType: RelDataType,
-      agg: Aggregate,
-      groupSet: Array[Int],
-      auxGroupSet: Array[Int],
-      aggFunctions: Array[UserDefinedFunction],
-      aggBufferTypes: Array[Array[InternalType]]): RelDataType = {
-
-    val typeFactory = agg.getCluster.getTypeFactory.asInstanceOf[FlinkTypeFactory]
-    val aggCallNames = Util.skip(
-      agg.getRowType.getFieldNames, groupSet.length + auxGroupSet.length).toList.toArray[String]
-    inferLocalAggType(
-      inputRowType, typeFactory, aggCallNames, groupSet, auxGroupSet, aggFunctions, aggBufferTypes)
-  }
-
-  protected def inferLocalAggType(
-      inputRowType: RelDataType,
-      typeFactory: FlinkTypeFactory,
-      aggCallNames: Array[String],
-      groupSet: Array[Int],
-      auxGroupSet: Array[Int],
-      aggFunctions: Array[UserDefinedFunction],
-      aggBufferTypes: Array[Array[InternalType]]): RelDataType = {
-
-    val aggBufferFieldNames = new Array[Array[String]](aggFunctions.length)
-    var index = -1
-    aggFunctions.zipWithIndex.foreach {
-      case (udf, aggIndex) =>
-        aggBufferFieldNames(aggIndex) = udf match {
-          case _: AggregateFunction[_, _] =>
-            Array(aggCallNames(aggIndex))
-          case agf: DeclarativeAggregateFunction =>
-            agf.aggBufferAttributes.map { attr =>
-              index += 1
-              s"${attr.getName}$$$index"
-            }
-          case _: UserDefinedFunction =>
-            throw new TableException(s"Don't get localAgg merge name")
-        }
-    }
-
-    // local agg output order: groupSet + auxGroupSet + aggCalls
-    val aggBufferSqlTypes = aggBufferTypes.flatten.map { t =>
-      val nullable = !FlinkTypeFactory.isTimeIndicatorType(t)
-      typeFactory.createTypeFromInternalType(t, nullable)
-    }
-
-    val localAggFieldTypes = (
-      groupSet.map(inputRowType.getFieldList.get(_).getType) ++ // groupSet
-        auxGroupSet.map(inputRowType.getFieldList.get(_).getType) ++ // auxGroupSet
-        aggBufferSqlTypes // aggCalls
-      ).toList
-
-    val localAggFieldNames = (
-      groupSet.map(inputRowType.getFieldList.get(_).getName) ++ // groupSet
-        auxGroupSet.map(inputRowType.getFieldList.get(_).getName) ++ // auxGroupSet
-        aggBufferFieldNames.flatten.toArray[String] // aggCalls
-      ).toList
-
-    typeFactory.createStructType(localAggFieldTypes, localAggFieldNames)
-  }
-
-  protected def isTwoPhaseAggWorkable(
-      aggFunctions: Array[UserDefinedFunction],
-      tableConfig: TableConfig): Boolean = {
-    getAggEnforceStrategy(tableConfig) match {
-      case AggPhaseEnforcer.ONE_PHASE => false
-      case _ => doAllSupportMerge(aggFunctions)
-    }
-  }
-
-  protected def isOnePhaseAggWorkable(
-      agg: Aggregate,
-      aggFunctions: Array[UserDefinedFunction],
-      tableConfig: TableConfig): Boolean = {
-    getAggEnforceStrategy(tableConfig) match {
-      case AggPhaseEnforcer.ONE_PHASE => true
-      case AggPhaseEnforcer.TWO_PHASE => !doAllSupportMerge(aggFunctions)
-      case AggPhaseEnforcer.NONE =>
-        if (!doAllSupportMerge(aggFunctions)) {
-          true
-        } else {
-          // if ndv of group key in aggregate is Unknown and all aggFunctions are splittable,
-          // use two-phase agg.
-          // else whether choose one-phase agg or two-phase agg depends on CBO.
-          val mq = agg.getCluster.getMetadataQuery
-          mq.getDistinctRowCount(agg.getInput, agg.getGroupSet, null) != null
-        }
-    }
-  }
-
-  protected def doAllSupportMerge(aggFunctions: Array[UserDefinedFunction]): Boolean = {
-    val supportLocalAgg = aggFunctions.forall {
-      case _: DeclarativeAggregateFunction => true
-      case a => ifMethodExistInFunction("merge", a)
-    }
-    //it means grouping without aggregate functions
-    aggFunctions.isEmpty || supportLocalAgg
-  }
-
-  protected def isEnforceOnePhaseAgg(tableConfig: TableConfig): Boolean = {
-    getAggEnforceStrategy(tableConfig) == AggPhaseEnforcer.ONE_PHASE
-  }
-
-  protected def isEnforceTwoPhaseAgg(tableConfig: TableConfig): Boolean = {
-    getAggEnforceStrategy(tableConfig) == AggPhaseEnforcer.TWO_PHASE
-  }
-
-  protected def getAggEnforceStrategy(tableConfig: TableConfig): AggPhaseEnforcer.Value = {
-    val aggPrefConfig = tableConfig.getConf.getString(
-      PlannerConfigOptions.SQL_OPTIMIZER_AGG_PHASE_ENFORCER)
-    AggPhaseEnforcer.values.find(_.toString.equalsIgnoreCase(aggPrefConfig))
-      .getOrElse(throw new IllegalArgumentException(
-        "Agg phase enforcer can only set to be: NONE, ONE_PHASE, TWO_PHASE!"))
-  }
-
-  protected def isAggBufferFixedLength(agg: Aggregate): Boolean = {
-    val (_, aggCallsWithoutAuxGroupCalls) = AggregateUtil.checkAndSplitAggCalls(agg)
-    val (_, aggBufferTypes, _) = AggregateUtil.transformToBatchAggregateFunctions(
-      aggCallsWithoutAuxGroupCalls, agg.getInput.getRowType)
-
-    isAggBufferFixedLength(aggBufferTypes.map(_.map(TypeConverters.createInternalTypeFromTypeInfo)))
-  }
-
-  protected def isAggBufferFixedLength(aggBufferTypes: Array[Array[InternalType]]): Boolean = {
-    val aggBuffAttributesTypes = aggBufferTypes.flatten
-    val isAggBufferFixedLength = aggBuffAttributesTypes.forall(BinaryRow.isMutable)
-    // it means grouping without aggregate functions
-    aggBuffAttributesTypes.isEmpty || isAggBufferFixedLength
-  }
-
-  protected def createRelCollation(groupSet: Array[Int]): RelCollation = {
-    val fields = new JArrayList[RelFieldCollation]()
-    for (field <- groupSet) {
-      fields.add(RelFieldCollationUtil.of(field))
-    }
-    RelCollations.of(fields)
-  }
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/physical/batch/BatchExecHashAggRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/physical/batch/BatchExecHashAggRule.scala
deleted file mode 100644
index 7680271..0000000
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/physical/batch/BatchExecHashAggRule.scala
+++ /dev/null
@@ -1,180 +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.plan.rules.physical.batch
-
-import org.apache.flink.table.`type`.TypeConverters
-import org.apache.flink.table.api.{OperatorType, PlannerConfigOptions}
-import org.apache.flink.table.calcite.FlinkContext
-import org.apache.flink.table.plan.`trait`.FlinkRelDistribution
-import org.apache.flink.table.plan.nodes.FlinkConventions
-import org.apache.flink.table.plan.nodes.logical.FlinkLogicalAggregate
-import org.apache.flink.table.plan.nodes.physical.batch.{BatchExecHashAggregate, BatchExecLocalHashAggregate}
-import org.apache.flink.table.plan.util.AggregateUtil
-
-import org.apache.calcite.plan.RelOptRule.{any, operand}
-import org.apache.calcite.plan.{RelOptRule, RelOptRuleCall}
-import org.apache.calcite.rel.RelNode
-
-import scala.collection.JavaConversions._
-
-/**
-  * Rule that matches [[FlinkLogicalAggregate]] which all aggregate function buffer are fix length,
-  * and converts it to
-  * {{{
-  *   BatchExecHashAggregate (global)
-  *   +- BatchExecExchange (hash by group keys if group keys is not empty, else singleton)
-  *      +- BatchExecLocalHashAggregate (local)
-  *         +- input of agg
-  * }}}
-  * when all aggregate functions are mergeable
-  * and [[PlannerConfigOptions.SQL_OPTIMIZER_AGG_PHASE_ENFORCER]] is TWO_PHASE, or
-  * {{{
-  *   BatchExecHashAggregate
-  *   +- BatchExecExchange (hash by group keys if group keys is not empty, else singleton)
-  *      +- input of agg
-  * }}}
-  * when some aggregate functions are not mergeable
-  * or [[PlannerConfigOptions.SQL_OPTIMIZER_AGG_PHASE_ENFORCER]] is ONE_PHASE.
-  *
-  * Notes: if [[PlannerConfigOptions.SQL_OPTIMIZER_AGG_PHASE_ENFORCER]] is NONE,
-  * this rule will try to create two possibilities above, and chooses the best one based on cost.
-  */
-class BatchExecHashAggRule
-  extends RelOptRule(
-    operand(classOf[FlinkLogicalAggregate],
-      operand(classOf[RelNode], any)),
-    "BatchExecHashAggRule")
-  with BatchExecAggRuleBase {
-
-  override def matches(call: RelOptRuleCall): Boolean = {
-    val tableConfig = call.getPlanner.getContext.asInstanceOf[FlinkContext].getTableConfig
-    if (!tableConfig.isOperatorEnabled(OperatorType.HashAgg)) {
-      return false
-    }
-    val agg: FlinkLogicalAggregate = call.rel(0)
-    // HashAgg cannot process aggregate whose agg buffer is not fix length
-    isAggBufferFixedLength(agg)
-  }
-
-  override def onMatch(call: RelOptRuleCall): Unit = {
-    val tableConfig = call.getPlanner.getContext.asInstanceOf[FlinkContext].getTableConfig
-    val agg: FlinkLogicalAggregate = call.rel(0)
-    val input: RelNode = call.rels(1)
-    val inputRowType = input.getRowType
-
-    if (agg.indicator) {
-      throw new UnsupportedOperationException("Not support group sets aggregate now.")
-    }
-
-    val groupSet = agg.getGroupSet.toArray
-    val (auxGroupSet, aggCallsWithoutAuxGroupCalls) = AggregateUtil.checkAndSplitAggCalls(agg)
-
-    val (_, aggBufferTypes, aggFunctions) = AggregateUtil.transformToBatchAggregateFunctions(
-      aggCallsWithoutAuxGroupCalls, inputRowType)
-
-    val aggCallToAggFunction = aggCallsWithoutAuxGroupCalls.zip(aggFunctions)
-    val aggProvidedTraitSet = agg.getTraitSet.replace(FlinkConventions.BATCH_PHYSICAL)
-
-    // create two-phase agg if possible
-    if (isTwoPhaseAggWorkable(aggFunctions, tableConfig)) {
-      // create BatchExecLocalHashAggregate
-      val localAggRowType = inferLocalAggType(
-        inputRowType,
-        agg,
-        groupSet,
-        auxGroupSet,
-        aggFunctions,
-        aggBufferTypes.map(_.map(TypeConverters.createInternalTypeFromTypeInfo)))
-      val localRequiredTraitSet = input.getTraitSet.replace(FlinkConventions.BATCH_PHYSICAL)
-      val newInput = RelOptRule.convert(input, localRequiredTraitSet)
-      val providedTraitSet = localRequiredTraitSet
-      val localHashAgg = new BatchExecLocalHashAggregate(
-        agg.getCluster,
-        call.builder(),
-        providedTraitSet,
-        newInput,
-        localAggRowType,
-        inputRowType,
-        groupSet,
-        auxGroupSet,
-        aggCallToAggFunction)
-
-      // create global BatchExecHashAggregate
-      val globalGroupSet = groupSet.indices.toArray
-      val globalAuxGroupSet = (groupSet.length until groupSet.length + auxGroupSet.length).toArray
-      val globalDistributions = if (agg.getGroupCount != 0) {
-        val distributionFields = globalGroupSet.map(Integer.valueOf).toList
-        Seq(
-          FlinkRelDistribution.hash(distributionFields),
-          FlinkRelDistribution.hash(distributionFields, requireStrict = false))
-      } else {
-        Seq(FlinkRelDistribution.SINGLETON)
-      }
-      globalDistributions.foreach { globalDistribution =>
-        val requiredTraitSet = localHashAgg.getTraitSet.replace(globalDistribution)
-        val newLocalHashAgg = RelOptRule.convert(localHashAgg, requiredTraitSet)
-        val globalHashAgg = new BatchExecHashAggregate(
-          agg.getCluster,
-          call.builder(),
-          aggProvidedTraitSet,
-          newLocalHashAgg,
-          agg.getRowType,
-          newLocalHashAgg.getRowType,
-          globalGroupSet,
-          globalAuxGroupSet,
-          aggCallToAggFunction,
-          true)
-        call.transformTo(globalHashAgg)
-      }
-    }
-
-    // create one-phase agg if possible
-    if (isOnePhaseAggWorkable(agg, aggFunctions, tableConfig)) {
-      val requiredDistributions = if (agg.getGroupCount != 0) {
-        val distributionFields = groupSet.map(Integer.valueOf).toList
-        Seq(
-          FlinkRelDistribution.hash(distributionFields, requireStrict = false),
-          FlinkRelDistribution.hash(distributionFields))
-      } else {
-        Seq(FlinkRelDistribution.SINGLETON)
-      }
-      requiredDistributions.foreach { requiredDistribution =>
-        val requiredTraitSet = input.getTraitSet
-          .replace(FlinkConventions.BATCH_PHYSICAL)
-          .replace(requiredDistribution)
-        val newInput = RelOptRule.convert(input, requiredTraitSet)
-        val hashAgg = new BatchExecHashAggregate(
-          agg.getCluster,
-          call.builder(),
-          aggProvidedTraitSet,
-          newInput,
-          agg.getRowType,
-          input.getRowType,
-          groupSet,
-          auxGroupSet,
-          aggCallToAggFunction,
-          false)
-        call.transformTo(hashAgg)
-      }
-    }
-  }
-}
-
-object BatchExecHashAggRule {
-  val INSTANCE = new BatchExecHashAggRule
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/physical/batch/BatchExecSortAggRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/physical/batch/BatchExecSortAggRule.scala
deleted file mode 100644
index 1193fcf..0000000
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/rules/physical/batch/BatchExecSortAggRule.scala
+++ /dev/null
@@ -1,193 +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.plan.rules.physical.batch
-
-import org.apache.flink.table.`type`.TypeConverters
-import org.apache.flink.table.api.{OperatorType, PlannerConfigOptions}
-import org.apache.flink.table.calcite.FlinkContext
-import org.apache.flink.table.plan.`trait`.FlinkRelDistribution
-import org.apache.flink.table.plan.nodes.FlinkConventions
-import org.apache.flink.table.plan.nodes.logical.FlinkLogicalAggregate
-import org.apache.flink.table.plan.nodes.physical.batch.{BatchExecLocalSortAggregate, BatchExecSortAggregate}
-import org.apache.flink.table.plan.util.{AggregateUtil, FlinkRelOptUtil}
-
-import org.apache.calcite.plan.RelOptRule.{any, operand}
-import org.apache.calcite.plan.{RelOptRule, RelOptRuleCall}
-import org.apache.calcite.rel._
-
-import scala.collection.JavaConversions._
-
-/**
-  * Rule that converts [[FlinkLogicalAggregate]] to
-  * {{{
-  *   BatchExecSortAggregate (global)
-  *   +- Sort (exists if group keys are not empty)
-  *      +- BatchExecExchange (hash by group keys if group keys is not empty, else singleton)
-  *         +- BatchExecLocalSortAggregate (local)
-  *           +- Sort (exists if group keys are not empty)
-  *              +- input of agg
-  * }}}
-  * when all aggregate functions are mergeable
-  * and [[PlannerConfigOptions.SQL_OPTIMIZER_AGG_PHASE_ENFORCER]] is TWO_PHASE, or
-  * {{{
-  *   BatchExecSortAggregate
-  *   +- Sort (exists if group keys are not empty)
-  *      +- BatchExecExchange (hash by group keys if group keys is not empty, else singleton)
-  *         +- input of agg
-  * }}}
-  * when some aggregate functions are not mergeable
-  * or [[PlannerConfigOptions.SQL_OPTIMIZER_AGG_PHASE_ENFORCER]] is ONE_PHASE.
-  *
-  * Notes: if [[PlannerConfigOptions.SQL_OPTIMIZER_AGG_PHASE_ENFORCER]] is NONE,
-  * this rule will try to create two possibilities above, and chooses the best one based on cost.
-  */
-class BatchExecSortAggRule
-  extends RelOptRule(
-    operand(classOf[FlinkLogicalAggregate],
-      operand(classOf[RelNode], any)),
-    "BatchExecSortAggRule")
-  with BatchExecAggRuleBase {
-
-  override def matches(call: RelOptRuleCall): Boolean = {
-    val tableConfig = call.getPlanner.getContext.asInstanceOf[FlinkContext].getTableConfig
-    tableConfig.isOperatorEnabled(OperatorType.SortAgg)
-  }
-
-  override def onMatch(call: RelOptRuleCall): Unit = {
-    val tableConfig = call.getPlanner.getContext.asInstanceOf[FlinkContext].getTableConfig
-    val agg: FlinkLogicalAggregate = call.rel(0)
-    val input: RelNode = call.rel(1)
-    val inputRowType = input.getRowType
-
-    if (agg.indicator) {
-      throw new UnsupportedOperationException("Not support group sets aggregate now.")
-    }
-
-    val (auxGroupSet, aggCallsWithoutAuxGroupCalls) = AggregateUtil.checkAndSplitAggCalls(agg)
-
-    val (_, aggBufferTypes, aggFunctions) = AggregateUtil.transformToBatchAggregateFunctions(
-      aggCallsWithoutAuxGroupCalls, inputRowType)
-    val groupSet = agg.getGroupSet.toArray
-    val aggCallToAggFunction = aggCallsWithoutAuxGroupCalls.zip(aggFunctions)
-    // TODO aggregate include projection now, so do not provide new trait will be safe
-    val aggProvidedTraitSet = agg.getTraitSet.replace(FlinkConventions.BATCH_PHYSICAL)
-
-    // create two-phase agg if possible
-    if (isTwoPhaseAggWorkable(aggFunctions, tableConfig)) {
-      val localAggRelType = inferLocalAggType(
-        inputRowType,
-        agg,
-        groupSet,
-        auxGroupSet,
-        aggFunctions,
-        aggBufferTypes.map(_.map(TypeConverters.createInternalTypeFromTypeInfo)))
-      // create BatchExecLocalSortAggregate
-      var localRequiredTraitSet = input.getTraitSet.replace(FlinkConventions.BATCH_PHYSICAL)
-      if (agg.getGroupCount != 0) {
-        val sortCollation = createRelCollation(groupSet)
-        localRequiredTraitSet = localRequiredTraitSet.replace(sortCollation)
-      }
-      val newLocalInput = RelOptRule.convert(input, localRequiredTraitSet)
-      val providedLocalTraitSet = localRequiredTraitSet
-      val localSortAgg = new BatchExecLocalSortAggregate(
-        agg.getCluster,
-        call.builder(),
-        providedLocalTraitSet,
-        newLocalInput,
-        localAggRelType,
-        newLocalInput.getRowType,
-        groupSet,
-        auxGroupSet,
-        aggCallToAggFunction)
-
-      // create global BatchExecSortAggregate
-      val globalGroupSet = groupSet.indices.toArray
-      val globalAuxGroupSet = (groupSet.length until groupSet.length + auxGroupSet.length).toArray
-      val (globalDistributions, globalCollation) = if (agg.getGroupCount != 0) {
-        // global agg should use groupSet's indices as distribution fields
-        val distributionFields = globalGroupSet.map(Integer.valueOf).toList
-        (
-          Seq(
-            FlinkRelDistribution.hash(distributionFields),
-            FlinkRelDistribution.hash(distributionFields, requireStrict = false)),
-          createRelCollation(globalGroupSet)
-        )
-      } else {
-        (Seq(FlinkRelDistribution.SINGLETON), RelCollations.EMPTY)
-      }
-      globalDistributions.foreach { globalDistribution =>
-        val requiredTraitSet = localSortAgg.getTraitSet
-          .replace(globalDistribution)
-          .replace(globalCollation)
-
-        val newInputForFinalAgg = RelOptRule.convert(localSortAgg, requiredTraitSet)
-        val globalSortAgg = new BatchExecSortAggregate(
-          agg.getCluster,
-          call.builder(),
-          aggProvidedTraitSet,
-          newInputForFinalAgg,
-          agg.getRowType,
-          newInputForFinalAgg.getRowType,
-          globalGroupSet,
-          globalAuxGroupSet,
-          aggCallToAggFunction,
-          isMerge = true)
-        call.transformTo(globalSortAgg)
-      }
-    }
-
-    // create one-phase agg if possible
-    if (isOnePhaseAggWorkable(agg, aggFunctions, tableConfig)) {
-      val requiredDistributions = if (agg.getGroupCount != 0) {
-        val distributionFields = groupSet.map(Integer.valueOf).toList
-        Seq(
-          FlinkRelDistribution.hash(distributionFields),
-          FlinkRelDistribution.hash(distributionFields, requireStrict = false))
-      } else {
-        Seq(FlinkRelDistribution.SINGLETON)
-      }
-      requiredDistributions.foreach { requiredDistribution =>
-        var requiredTraitSet = input.getTraitSet
-          .replace(FlinkConventions.BATCH_PHYSICAL)
-          .replace(requiredDistribution)
-        if (agg.getGroupCount != 0) {
-          val sortCollation = createRelCollation(groupSet)
-          requiredTraitSet = requiredTraitSet.replace(sortCollation)
-        }
-        val newInput = RelOptRule.convert(input, requiredTraitSet)
-        val sortAgg = new BatchExecSortAggregate(
-          agg.getCluster,
-          call.builder(),
-          aggProvidedTraitSet,
-          newInput,
-          agg.getRowType,
-          newInput.getRowType,
-          groupSet,
-          auxGroupSet,
-          aggCallToAggFunction,
-          isMerge = false
-        )
-        call.transformTo(sortAgg)
-      }
-    }
-  }
-}
-
-object BatchExecSortAggRule {
-  val INSTANCE = new BatchExecSortAggRule
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/util/AggFunctionFactory.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/util/AggFunctionFactory.scala
deleted file mode 100644
index 96ecdd8..0000000
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/util/AggFunctionFactory.scala
+++ /dev/null
@@ -1,250 +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.plan.util
-
-import org.apache.flink.table.`type`.InternalTypes._
-import org.apache.flink.table.`type`.{DecimalType, InternalType}
-import org.apache.flink.table.api.TableException
-import org.apache.flink.table.calcite.FlinkTypeFactory
-import org.apache.flink.table.functions.UserDefinedFunction
-import org.apache.flink.table.functions.utils.AggSqlFunction
-import org.apache.flink.table.typeutils.DecimalTypeInfo
-
-import org.apache.calcite.rel.`type`.RelDataType
-import org.apache.calcite.rel.core.AggregateCall
-import org.apache.calcite.sql.fun._
-import org.apache.calcite.sql.{SqlAggFunction, SqlKind}
-
-import scala.collection.JavaConversions._
-
-/**
-  * The class of agg function factory which is used to create AggregateFunction or
-  * DeclarativeAggregateFunction from Calcite AggregateCall
-  *
-  * @param inputType the input rel data type
-  * @param orderKeyIdx the indexes of order key (null when is not over agg)
-  * @param needRetraction true if need retraction
-  */
-class AggFunctionFactory(
-    inputType: RelDataType,
-    orderKeyIdx: Array[Int],
-    needRetraction: Array[Boolean]) {
-
-  /**
-    * The entry point to create an aggregate function from the given AggregateCall
-    */
-  def createAggFunction(call: AggregateCall, index: Int): UserDefinedFunction = {
-
-    val argTypes: Array[InternalType] = call.getArgList
-      .map(inputType.getFieldList.get(_).getType) // RelDataType
-      .map(FlinkTypeFactory.toInternalType) // InternalType
-      .toArray
-
-    call.getAggregation match {
-      case a: SqlAvgAggFunction if a.kind == SqlKind.AVG => createAvgAggFunction(argTypes)
-
-      case _: SqlSumAggFunction => createSumAggFunction(argTypes, index)
-
-      case _: SqlSumEmptyIsZeroAggFunction => createSum0AggFunction(argTypes)
-
-      // TODO supports SqlIncrSumAggFunction
-
-      case a: SqlMinMaxAggFunction if a.getKind == SqlKind.MIN =>
-        createMinAggFunction(argTypes, index)
-
-      case a: SqlMinMaxAggFunction if a.getKind == SqlKind.MAX =>
-        createMaxAggFunction(argTypes, index)
-
-      case _: SqlCountAggFunction if call.getArgList.size() > 1 =>
-        throw new TableException("We now only support the count of one field.")
-
-      // TODO supports ApproximateCountDistinctAggFunction and CountDistinctAggFunction
-
-      case _: SqlCountAggFunction if call.getArgList.isEmpty => createCount1AggFunction(argTypes)
-
-      case _: SqlCountAggFunction => createCountAggFunction(argTypes)
-
-      // TODO supports SqlRankFunction (ROW_NUMBER, RANK and DENSE_RANK)
-      // TODO supports SqlLeadLagAggFunction
-      // TODO supports SqlMax2ndAggFunction
-      // TODO supports SqlSingleValueAggFunction
-      // TODO supports SqlFirstLastValueAggFunction (FIRST_VALUE and LAST_VALUE)
-      // TODO supports SqlConcatAggFunction
-      // TODO supports SqlCardinalityCountAggFunction
-      // TODO supports COLLECT SqlAggFunction
-
-      case udagg: AggSqlFunction => udagg.getFunction
-
-      case unSupported: SqlAggFunction =>
-        throw new TableException(s"Unsupported Function: '${unSupported.getName}'")
-    }
-  }
-
-  private def createAvgAggFunction(argTypes: Array[InternalType]): UserDefinedFunction = {
-    argTypes(0) match {
-      case BYTE | SHORT | INT | LONG =>
-        new org.apache.flink.table.functions.AvgAggFunction.IntegralAvgAggFunction
-      case FLOAT | DOUBLE =>
-        new org.apache.flink.table.functions.AvgAggFunction.DoubleAvgAggFunction
-      case d: DecimalType =>
-        val decimalTypeInfo = DecimalTypeInfo.of(d.precision(), d.scale())
-        new org.apache.flink.table.functions.AvgAggFunction.DecimalAvgAggFunction(decimalTypeInfo)
-      case t: InternalType =>
-        throw new TableException(s"Avg aggregate function does not support type: ''$t''.\n" +
-          s"Please re-check the data type.")
-    }
-  }
-
-  private def createSumAggFunction(argTypes: Array[InternalType], index: Int)
-  : UserDefinedFunction = {
-    if (needRetraction(index)) {
-      // TODO implements this
-      throw new TableException("Unsupported now")
-    } else {
-      argTypes(0) match {
-        case BYTE =>
-          new org.apache.flink.table.functions.SumAggFunction.ByteSumAggFunction
-        case SHORT =>
-          new org.apache.flink.table.functions.SumAggFunction.ShortSumAggFunction
-        case INT =>
-          new org.apache.flink.table.functions.SumAggFunction.IntSumAggFunction
-        case LONG =>
-          new org.apache.flink.table.functions.SumAggFunction.LongSumAggFunction
-        case FLOAT =>
-          new org.apache.flink.table.functions.SumAggFunction.FloatSumAggFunction
-        case DOUBLE =>
-          new org.apache.flink.table.functions.SumAggFunction.DoubleSumAggFunction
-        case d: DecimalType =>
-          val decimalTypeInfo = DecimalTypeInfo.of(d.precision(), d.scale())
-          new org.apache.flink.table.functions.SumAggFunction.DecimalSumAggFunction(decimalTypeInfo)
-        case t: InternalType =>
-          throw new TableException(s"Sum aggregate function does not support type: ''$t''.\n" +
-            s"Please re-check the data type.")
-      }
-    }
-  }
-
-  private def createSum0AggFunction(argTypes: Array[InternalType]): UserDefinedFunction = {
-    argTypes(0) match {
-      case BYTE =>
-        new org.apache.flink.table.functions.Sum0AggFunction.ByteSum0AggFunction
-      case SHORT =>
-        new org.apache.flink.table.functions.Sum0AggFunction.ShortSum0AggFunction
-      case INT =>
-        new org.apache.flink.table.functions.Sum0AggFunction.IntSum0AggFunction
-      case LONG =>
-        new org.apache.flink.table.functions.Sum0AggFunction.LongSum0AggFunction
-      case FLOAT =>
-        new org.apache.flink.table.functions.Sum0AggFunction.FloatSum0AggFunction
-      case DOUBLE =>
-        new org.apache.flink.table.functions.Sum0AggFunction.DoubleSum0AggFunction
-      case d: DecimalType =>
-        val decimalTypeInfo = DecimalTypeInfo.of(d.precision(), d.scale())
-        new org.apache.flink.table.functions.Sum0AggFunction.DecimalSum0AggFunction(decimalTypeInfo)
-      case t: InternalType =>
-        throw new TableException(s"Sum0 aggregate function does not support type: ''$t''.\n" +
-          s"Please re-check the data type.")
-    }
-  }
-
-  private def createMinAggFunction(
-      argTypes: Array[InternalType], index: Int): UserDefinedFunction = {
-    if (needRetraction(index)) {
-      // TODO implements this
-      throw new TableException("Unsupported now")
-    } else {
-      argTypes(0) match {
-        case BYTE =>
-          new org.apache.flink.table.functions.MinAggFunction.ByteMinAggFunction
-        case SHORT =>
-          new org.apache.flink.table.functions.MinAggFunction.ShortMinAggFunction
-        case INT =>
-          new org.apache.flink.table.functions.MinAggFunction.IntMinAggFunction
-        case LONG =>
-          new org.apache.flink.table.functions.MinAggFunction.LongMinAggFunction
-        case FLOAT =>
-          new org.apache.flink.table.functions.MinAggFunction.FloatMinAggFunction
-        case DOUBLE =>
-          new org.apache.flink.table.functions.MinAggFunction.DoubleMinAggFunction
-        case BOOLEAN =>
-          new org.apache.flink.table.functions.MinAggFunction.BooleanMinAggFunction
-        case STRING =>
-          new org.apache.flink.table.functions.MinAggFunction.StringMinAggFunction
-        case DATE =>
-          new org.apache.flink.table.functions.MinAggFunction.DateMinAggFunction
-        case TIME =>
-          new org.apache.flink.table.functions.MinAggFunction.TimeMinAggFunction
-        case TIMESTAMP |  PROCTIME_INDICATOR | ROWTIME_INDICATOR =>
-          new org.apache.flink.table.functions.MinAggFunction.TimestampMinAggFunction
-        case d: DecimalType =>
-          val decimalTypeInfo = DecimalTypeInfo.of(d.precision(), d.scale())
-          new org.apache.flink.table.functions.MinAggFunction.DecimalMinAggFunction(decimalTypeInfo)
-        case t: InternalType =>
-          throw new TableException(s"Min aggregate function does not support type: ''$t''.\n" +
-            s"Please re-check the data type.")
-      }
-    }
-  }
-
-  private def createMaxAggFunction(
-      argTypes: Array[InternalType], index: Int): UserDefinedFunction = {
-    if (needRetraction(index)) {
-      // TODO implements this
-      throw new TableException("Unsupported now")
-    } else {
-      argTypes(0) match {
-        case BYTE =>
-          new org.apache.flink.table.functions.MaxAggFunction.ByteMaxAggFunction
-        case SHORT =>
-          new org.apache.flink.table.functions.MaxAggFunction.ShortMaxAggFunction
-        case INT =>
-          new org.apache.flink.table.functions.MaxAggFunction.IntMaxAggFunction
-        case LONG =>
-          new org.apache.flink.table.functions.MaxAggFunction.LongMaxAggFunction
-        case FLOAT =>
-          new org.apache.flink.table.functions.MaxAggFunction.FloatMaxAggFunction
-        case DOUBLE =>
-          new org.apache.flink.table.functions.MaxAggFunction.DoubleMaxAggFunction
-        case BOOLEAN =>
-          new org.apache.flink.table.functions.MaxAggFunction.BooleanMaxAggFunction
-        case STRING =>
-          new org.apache.flink.table.functions.MaxAggFunction.StringMaxAggFunction
-        case DATE =>
-          new org.apache.flink.table.functions.MaxAggFunction.DateMaxAggFunction
-        case TIME =>
-          new org.apache.flink.table.functions.MaxAggFunction.TimeMaxAggFunction
-        case TIMESTAMP | PROCTIME_INDICATOR | ROWTIME_INDICATOR =>
-          new org.apache.flink.table.functions.MaxAggFunction.TimestampMaxAggFunction
-        case d: DecimalType =>
-          val decimalTypeInfo = DecimalTypeInfo.of(d.precision(), d.scale())
-          new org.apache.flink.table.functions.MaxAggFunction.DecimalMaxAggFunction(decimalTypeInfo)
-        case t: InternalType =>
-          throw new TableException(s"Max aggregate function does not support type: ''$t''.\n" +
-            s"Please re-check the data type.")
-      }
-    }
-  }
-
-  private def createCount1AggFunction(argTypes: Array[InternalType]): UserDefinedFunction = {
-    new org.apache.flink.table.functions.Count1AggFunction
-  }
-
-  private def createCountAggFunction(argTypes: Array[InternalType]): UserDefinedFunction = {
-    new org.apache.flink.table.functions.CountAggFunction
-  }
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/util/AggregateUtil.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/util/AggregateUtil.scala
deleted file mode 100644
index 3e54ee2..0000000
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/util/AggregateUtil.scala
+++ /dev/null
@@ -1,498 +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.plan.util
-
-import org.apache.flink.api.common.typeinfo.{TypeInformation, Types}
-import org.apache.flink.table.`type`.InternalTypes._
-import org.apache.flink.table.`type`.{DecimalType, InternalType, InternalTypes, RowType, TypeConverters}
-import org.apache.flink.table.api.TableException
-import org.apache.flink.table.calcite.{FlinkTypeFactory, FlinkTypeSystem}
-import org.apache.flink.table.dataview.DataViewSpec
-import org.apache.flink.table.dataview.DataViewUtils.useNullSerializerForStateViewFieldsFromAccType
-import org.apache.flink.table.functions.sql.AggSqlFunctions
-import org.apache.flink.table.functions.utils.UserDefinedFunctionUtils._
-import org.apache.flink.table.functions.{AggregateFunction, DeclarativeAggregateFunction, UserDefinedFunction}
-import org.apache.flink.table.typeutils.{BinaryStringTypeInfo, DecimalTypeInfo, MapViewTypeInfo}
-
-import org.apache.calcite.rel.`type`._
-import org.apache.calcite.rel.core.{Aggregate, AggregateCall}
-import org.apache.calcite.sql.SqlRankFunction
-import org.apache.calcite.sql.fun._
-
-import java.util
-
-import scala.collection.JavaConversions._
-import scala.collection.mutable
-import scala.collection.mutable.ArrayBuffer
-
-object AggregateUtil extends Enumeration {
-
-  /**
-    * Check whether AUXILIARY_GROUP aggCalls is in the front of the given agg's aggCallList,
-    * and whether aggCallList contain AUXILIARY_GROUP when the given agg's groupSet is empty
-    * or the indicator is true.
-    * Returns AUXILIARY_GROUP aggCalls' args and other aggCalls.
-    *
-    * @param agg aggregate
-    * @return returns AUXILIARY_GROUP aggCalls' args and other aggCalls
-    */
-  def checkAndSplitAggCalls(agg: Aggregate): (Array[Int], Seq[AggregateCall]) = {
-    var nonAuxGroupCallsStartIdx = -1
-
-    val aggCalls = agg.getAggCallList
-    aggCalls.zipWithIndex.foreach {
-      case (call, idx) =>
-        if (call.getAggregation == AggSqlFunctions.AUXILIARY_GROUP) {
-          require(call.getArgList.size == 1)
-        }
-        if (nonAuxGroupCallsStartIdx >= 0) {
-          // the left aggCalls should not be AUXILIARY_GROUP
-          require(call.getAggregation != AggSqlFunctions.AUXILIARY_GROUP,
-            "AUXILIARY_GROUP should be in the front of aggCall list")
-        }
-        if (nonAuxGroupCallsStartIdx < 0 &&
-          call.getAggregation != AggSqlFunctions.AUXILIARY_GROUP) {
-          nonAuxGroupCallsStartIdx = idx
-        }
-    }
-
-    if (nonAuxGroupCallsStartIdx < 0) {
-      nonAuxGroupCallsStartIdx = aggCalls.length
-    }
-
-    val (auxGroupCalls, otherAggCalls) = aggCalls.splitAt(nonAuxGroupCallsStartIdx)
-    if (agg.getGroupCount == 0) {
-      require(auxGroupCalls.isEmpty,
-        "AUXILIARY_GROUP aggCalls should be empty when groupSet is empty")
-    }
-    if (agg.indicator) {
-      require(auxGroupCalls.isEmpty,
-        "AUXILIARY_GROUP aggCalls should be empty when indicator is true")
-    }
-
-    val auxGrouping = auxGroupCalls.map(_.getArgList.head.toInt).toArray
-    require(auxGrouping.length + otherAggCalls.length == aggCalls.length)
-    (auxGrouping, otherAggCalls)
-  }
-
-  def checkAndGetFullGroupSet(agg: Aggregate): Array[Int] = {
-    val (auxGroupSet, _) = checkAndSplitAggCalls(agg)
-    agg.getGroupSet.toArray ++ auxGroupSet
-  }
-
-  def transformToBatchAggregateFunctions(
-      aggregateCalls: Seq[AggregateCall],
-      inputRowType: RelDataType,
-      orderKeyIdx: Array[Int] = null)
-  : (Array[Array[Int]], Array[Array[TypeInformation[_]]], Array[UserDefinedFunction]) = {
-
-    val aggInfos = transformToAggregateInfoList(
-      aggregateCalls,
-      inputRowType,
-      orderKeyIdx,
-      Array.fill(aggregateCalls.size)(false),
-      needInputCount = false,
-      isStateBackedDataViews = false,
-      needDistinctInfo = false).aggInfos
-
-    val aggFields = aggInfos.map(_.argIndexes)
-    val bufferTypes = aggInfos.map(_.externalAccTypes)
-    val functions = aggInfos.map(_.function)
-
-    (aggFields, bufferTypes, functions)
-  }
-
-  def transformToBatchAggregateInfoList(
-      aggregateCalls: Seq[AggregateCall],
-      inputRowType: RelDataType,
-      orderKeyIdx: Array[Int] = null,
-      needRetractions: Array[Boolean] = null): AggregateInfoList = {
-
-    val needRetractionArray = if (needRetractions == null) {
-      Array.fill(aggregateCalls.size)(false)
-    } else {
-      needRetractions
-    }
-
-    transformToAggregateInfoList(
-      aggregateCalls,
-      inputRowType,
-      orderKeyIdx,
-      needRetractionArray,
-      needInputCount = false,
-      isStateBackedDataViews = false,
-      needDistinctInfo = false)
-  }
-
-  def transformToStreamAggregateInfoList(
-      aggregateCalls: Seq[AggregateCall],
-      inputRowType: RelDataType,
-      needRetraction: Array[Boolean],
-      needInputCount: Boolean,
-      isStateBackendDataViews: Boolean,
-      needDistinctInfo: Boolean = true): AggregateInfoList = {
-    transformToAggregateInfoList(
-      aggregateCalls,
-      inputRowType,
-      orderKeyIdx = null,
-      needRetraction ++ Array(needInputCount), // for additional count1
-      needInputCount,
-      isStateBackendDataViews,
-      needDistinctInfo)
-  }
-
-  /**
-    * Transforms calcite aggregate calls to AggregateInfos.
-    *
-    * @param aggregateCalls   the calcite aggregate calls
-    * @param inputRowType     the input rel data type
-    * @param orderKeyIdx      the index of order by field in the input, null if not over agg
-    * @param needRetraction   whether the aggregate function need retract method
-    * @param needInputCount   whether need to calculate the input counts, which is used in
-    *                         aggregation with retraction input.If needed,
-    *                         insert a count(1) aggregate into the agg list.
-    * @param isStateBackedDataViews   whether the dataview in accumulator use state or heap
-    * @param needDistinctInfo  whether need to extract distinct information
-    */
-  private def transformToAggregateInfoList(
-      aggregateCalls: Seq[AggregateCall],
-      inputRowType: RelDataType,
-      orderKeyIdx: Array[Int],
-      needRetraction: Array[Boolean],
-      needInputCount: Boolean,
-      isStateBackedDataViews: Boolean,
-      needDistinctInfo: Boolean): AggregateInfoList = {
-
-    // Step-1:
-    // if need inputCount, find count1 in the existed aggregate calls first,
-    // if not exist, insert a new count1 and remember the index
-    val (count1AggIndex, count1AggInserted, aggCalls) = insertInputCountAggregate(
-      needInputCount,
-      aggregateCalls)
-
-    // Step-2:
-    // extract distinct information from aggregate calls
-    val (distinctInfos, newAggCalls) = extractDistinctInformation(
-      needDistinctInfo,
-      aggCalls,
-      inputRowType,
-      isStateBackedDataViews,
-      needInputCount) // needInputCount means whether the aggregate consume retractions
-
-    // Step-3:
-    // create aggregate information
-    val factory = new AggFunctionFactory(inputRowType, orderKeyIdx, needRetraction)
-    val aggInfos = newAggCalls.zipWithIndex.map { case (call, index) =>
-      val argIndexes = call.getAggregation match {
-        case _: SqlRankFunction => orderKeyIdx
-        case _ => call.getArgList.map(_.intValue()).toArray
-      }
-
-      val function = factory.createAggFunction(call, index)
-      val (externalAccTypes, viewSpecs, externalResultType) = function match {
-        case a: DeclarativeAggregateFunction =>
-          val bufferTypes: Array[InternalType] = a.getAggBufferTypes
-          val bufferTypeInfos = bufferTypes.map(
-            TypeConverters.createInternalTypeInfoFromInternalType)
-          (bufferTypeInfos, Array.empty[DataViewSpec], a.getResultType)
-        case a: AggregateFunction[_, _] =>
-          val externalAccType = getAccumulatorTypeOfAggregateFunction(a)
-          val (newExternalAccType, specs) = useNullSerializerForStateViewFieldsFromAccType(
-            index,
-            a,
-            externalAccType,
-            isStateBackedDataViews)
-          (Array(newExternalAccType), specs, getResultTypeOfAggregateFunction(a))
-        case _ => throw new TableException(s"Unsupported function: $function")
-      }
-
-      AggregateInfo(
-        call,
-        function,
-        index,
-        argIndexes,
-        externalAccTypes.asInstanceOf[Array[TypeInformation[_]]],
-        viewSpecs,
-        externalResultType,
-        needRetraction(index))
-
-    }.toArray
-
-    AggregateInfoList(aggInfos, count1AggIndex, count1AggInserted, distinctInfos)
-  }
-
-
-  /**
-    * Inserts an InputCount aggregate which is count1 actually if needed.
-    * @param needInputCount whether to insert an InputCount aggregate
-    * @param aggregateCalls original aggregate calls
-    * @return (count1AggIndex, count1AggInserted, newaggCalls)
-    */
-  private def insertInputCountAggregate(
-      needInputCount: Boolean,
-      aggregateCalls: Seq[AggregateCall]): (Option[Int], Boolean, Seq[AggregateCall]) = {
-
-    var count1AggIndex: Option[Int] = None
-    var count1AggInserted: Boolean = false
-    if (!needInputCount) {
-      return (count1AggIndex, count1AggInserted, aggregateCalls)
-    }
-
-    // if need inputCount, find count1 in the existed aggregate calls first,
-    // if not exist, insert a new count1 and remember the index
-    var newAggCalls = aggregateCalls
-    aggregateCalls.zipWithIndex.foreach { case (call, index) =>
-      if (call.getAggregation.isInstanceOf[SqlCountAggFunction] &&
-        call.filterArg < 0 &&
-        call.getArgList.isEmpty &&
-        !call.isApproximate &&
-        !call.isDistinct) {
-        count1AggIndex = Some(index)
-      }
-    }
-
-    // count1 not exist in aggregateCalls, insert a count1 in it.
-    val typeFactory = new FlinkTypeFactory(new FlinkTypeSystem)
-    if (count1AggIndex.isEmpty) {
-
-      val count1 = AggregateCall.create(
-        SqlStdOperatorTable.COUNT,
-        false,
-        false,
-        new util.ArrayList[Integer](),
-        -1,
-        typeFactory.createTypeFromInternalType(InternalTypes.LONG, isNullable = false),
-        "_$count1$_")
-
-      count1AggIndex = Some(aggregateCalls.length)
-      count1AggInserted = true
-      newAggCalls = aggregateCalls ++ Seq(count1)
-    }
-
-    (count1AggIndex, count1AggInserted, newAggCalls)
-  }
-
-  /**
-    * Extracts DistinctInfo array from the aggregate calls,
-    * and change the distinct aggregate to non-distinct aggregate.
-    *
-    * @param needDistinctInfo whether to extract distinct information
-    * @param aggCalls   the original aggregate calls
-    * @param inputType  the input rel data type
-    * @param isStateBackedDataViews whether the dataview in accumulator use state or heap
-    * @param consumeRetraction  whether the distinct aggregate consumes retraction messages
-    * @return (distinctInfoArray, newAggCalls)
-    */
-  private def extractDistinctInformation(
-      needDistinctInfo: Boolean,
-      aggCalls: Seq[AggregateCall],
-      inputType: RelDataType,
-      isStateBackedDataViews: Boolean,
-      consumeRetraction: Boolean)
-  : (Array[DistinctInfo], Seq[AggregateCall]) = {
-
-    if (!needDistinctInfo) {
-      return (Array(), aggCalls)
-    }
-
-    val distinctMap = mutable.LinkedHashMap.empty[String, DistinctInfo]
-    val newAggCalls = aggCalls.zipWithIndex.map { case (call, index) =>
-      val argIndexes = call.getArgList.map(_.intValue()).toArray
-
-      // extract distinct information and replace a new call
-      if (call.isDistinct && !call.isApproximate && argIndexes.length > 0) {
-        val argTypes: Array[InternalType] = call
-          .getArgList
-          .map(inputType.getFieldList.get(_).getType) // RelDataType
-          .map(FlinkTypeFactory.toInternalType) // InternalType
-          .toArray
-
-        val keyType = createDistinctKeyType(argTypes)
-        val distinctInfo = distinctMap.getOrElseUpdate(
-          argIndexes.mkString(","),
-          DistinctInfo(
-            argIndexes,
-            keyType,
-            null, // later fill in
-            excludeAcc = false,
-            null, // later fill in
-            consumeRetraction,
-            ArrayBuffer.empty[Int],
-            ArrayBuffer.empty[Int]))
-        // add current agg to the distinct agg list
-        distinctInfo.filterArgs += call.filterArg
-        distinctInfo.aggIndexes += index
-
-        AggregateCall.create(
-          call.getAggregation,
-          false,
-          false,
-          call.getArgList,
-          -1, // remove filterArg
-          call.getType,
-          call.getName)
-      } else {
-        call
-      }
-    }
-
-    // fill in the acc type and dataview spec
-    val distinctInfos = distinctMap.values.zipWithIndex.map { case (d, index) =>
-      val valueType = if (consumeRetraction) {
-        if (d.filterArgs.length <= 1) {
-          Types.LONG
-        } else {
-          Types.PRIMITIVE_ARRAY(Types.LONG)
-        }
-      } else {
-        if (d.filterArgs.length <= 64) {
-          Types.LONG
-        } else {
-          Types.PRIMITIVE_ARRAY(Types.LONG)
-        }
-      }
-
-      val accTypeInfo = new MapViewTypeInfo(
-        // distinct is internal code gen, use internal type serializer.
-        d.keyType,
-        valueType,
-        isStateBackedDataViews,
-        // the mapview serializer should handle null keys
-        nullAware = true)
-
-      val distinctMapViewSpec = if (isStateBackedDataViews) {
-        // TODO supports MapViewSpec
-        throw new TableException("MapViewSpec is not supported now")
-      } else {
-        None
-      }
-
-      DistinctInfo(
-        d.argIndexes,
-        d.keyType,
-        accTypeInfo,
-        excludeAcc = false,
-        distinctMapViewSpec,
-        consumeRetraction,
-        d.filterArgs,
-        d.aggIndexes)
-    }
-
-    (distinctInfos.toArray, newAggCalls)
-  }
-
-  def createDistinctKeyType(argTypes: Array[InternalType]): TypeInformation[_] = {
-    if (argTypes.length == 1) {
-      argTypes(0) match {
-        case BYTE => Types.BYTE
-        case SHORT => Types.SHORT
-        case INT => Types.INT
-        case LONG => Types.LONG
-        case FLOAT => Types.FLOAT
-        case DOUBLE => Types.DOUBLE
-        case BOOLEAN => Types.BOOLEAN
-        case DATE | TIME => Types.INT
-        case TIMESTAMP => Types.LONG
-        case STRING => BinaryStringTypeInfo.INSTANCE
-        case d: DecimalType => DecimalTypeInfo.of(d.precision(), d.scale())
-        case t =>
-          throw new TableException(s"Distinct aggregate function does not support type: $t.\n" +
-            s"Please re-check the data type.")
-      }
-    } else {
-      TypeConverters.createExternalTypeInfoFromInternalType(new RowType(argTypes: _*))
-    }
-  }
-
-  /**
-    * Return true if all aggregates can be partially merged. False otherwise.
-    */
-  def doAllSupportPartialMerge(aggInfos: Array[AggregateInfo]): Boolean = {
-    val supportMerge = aggInfos.map(_.function).forall {
-      case _: DeclarativeAggregateFunction => true
-      case a => ifMethodExistInFunction("merge", a)
-    }
-
-    //it means grouping without aggregate functions
-    aggInfos.isEmpty || supportMerge
-  }
-
-  /**
-    * Return true if all aggregates can be split. False otherwise.
-    */
-  def doAllAggSupportSplit(aggCalls: util.List[AggregateCall]): Boolean = {
-    // TODO supports SqlConcatAggFunction
-    aggCalls.forall { aggCall =>
-      aggCall.getAggregation match {
-        case _: SqlCountAggFunction |
-             _: SqlAvgAggFunction |
-             _: SqlMinMaxAggFunction |
-             _: SqlSumAggFunction |
-             _: SqlSumEmptyIsZeroAggFunction |
-             _: SqlSingleValueAggFunction => true
-        case _: SqlFirstLastValueAggFunction => aggCall.getArgList.size() == 1
-        case _ => false
-      }
-    }
-  }
-
-  /**
-    * Derives output row type from stream local aggregate
-    */
-  def inferStreamLocalAggRowType(
-      aggInfoList: AggregateInfoList,
-      inputType: RelDataType,
-      groupSet: Array[Int],
-      typeFactory: FlinkTypeFactory): RelDataType = {
-
-    val accTypes = aggInfoList.getAccTypes
-    val groupingTypes = groupSet
-      .map(inputType.getFieldList.get(_).getType)
-      .map(FlinkTypeFactory.toInternalType)
-    val groupingNames = groupSet.map(inputType.getFieldNames.get(_))
-    val accFieldNames = inferStreamAggAccumulatorNames(aggInfoList)
-
-    typeFactory.buildRelDataType(
-      groupingNames ++ accFieldNames,
-      groupingTypes ++ accTypes.map(TypeConverters.createInternalTypeFromTypeInfo))
-  }
-
-  /**
-    * Derives accumulators names from stream aggregate
-    */
-  def inferStreamAggAccumulatorNames(aggInfoList: AggregateInfoList): Array[String] = {
-    var index = -1
-    val aggBufferNames = aggInfoList.aggInfos.indices.flatMap { i =>
-      aggInfoList.aggInfos(i).function match {
-        case _: AggregateFunction[_, _] =>
-          val name = aggInfoList.aggInfos(i).agg.getAggregation.getName.toLowerCase
-          index += 1
-          Array(s"$name$$$index")
-        case daf: DeclarativeAggregateFunction =>
-          daf.aggBufferAttributes.map { a =>
-            index += 1
-            s"${a.getName}$$$index"
-          }
-      }
-    }
-    val distinctBufferNames = aggInfoList.distinctInfos.indices.map { i =>
-      s"distinct$$$i"
-    }
-    (aggBufferNames ++ distinctBufferNames).toArray
-  }
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/util/RelExplainUtil.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/util/RelExplainUtil.scala
index a72188b..cfcdd63 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/util/RelExplainUtil.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/plan/util/RelExplainUtil.scala
@@ -21,7 +21,6 @@ import org.apache.flink.table.CalcitePair
 import org.apache.flink.table.api.TableException
 import org.apache.flink.table.functions.utils.TableSqlFunction
 import org.apache.flink.table.functions.{AggregateFunction, UserDefinedFunction}
-import org.apache.flink.table.functions.{AggregateFunction, DeclarativeAggregateFunction, UserDefinedFunction}
 import org.apache.flink.table.plan.FlinkJoinRelType
 import org.apache.flink.table.plan.nodes.ExpressionFormat
 import org.apache.flink.table.plan.nodes.ExpressionFormat.ExpressionFormat
@@ -189,13 +188,9 @@ object RelExplainUtil {
               val argList = List(offset)
               offset = offset + 1
               argList
-            case daf: DeclarativeAggregateFunction =>
-              val aggBufferTypes = daf.getAggBufferTypes
-              val argList = aggBufferTypes.indices.map(offset + _).toList
-              offset = offset + aggBufferTypes.length
-              argList
             case _ =>
-              throw new TableException(s"Unsupported function: $udf")
+              // TODO supports DeclarativeAggregateFunction
+              throw new TableException("Unsupported now")
           }
         }
         val argListNames = if (aggToDistinctMapping.contains(index)) {
@@ -214,7 +209,7 @@ object RelExplainUtil {
         }
     }
 
-    // output for agg
+    //output for agg
     val aggFunctions = aggCallToAggFunction.map(_._2)
     offset = fullGrouping.length
     val outFieldNames = aggFunctions.map { udf =>
@@ -228,15 +223,9 @@ object RelExplainUtil {
             val name = outputFieldNames(offset)
             offset = offset + 1
             name
-          case daf: DeclarativeAggregateFunction =>
-            val aggBufferTypes = daf.getAggBufferTypes
-            val name = aggBufferTypes.indices
-              .map(i => outputFieldNames(offset + i))
-              .mkString(", ")
-            offset = offset + aggBufferTypes.length
-            if (aggBufferTypes.length > 1) s"($name)" else name
           case _ =>
-            throw new TableException(s"Unsupported function: $udf")
+            // TODO supports DeclarativeAggregateFunction
+            throw new TableException("Unsupported now")
         }
       }
       outFieldName
@@ -423,15 +412,9 @@ object RelExplainUtil {
           val name = accNames(offset)
           offset = offset + 1
           name
-        case daf: DeclarativeAggregateFunction =>
-          val aggBufferTypes = daf.getAggBufferTypes
-          val name = aggBufferTypes.indices
-            .map(i => accNames(offset + i))
-            .mkString(", ")
-          offset = offset + aggBufferTypes.length
-          if (aggBufferTypes.length > 1) s"($name)" else name
         case _ =>
-          throw new TableException(s"Unsupported function: ${info.function}")
+          // TODO supports DeclarativeAggregateFunction
+          throw new TableException("Unsupported now")
       }
     }
     val distinctFieldNames = (offset until accNames.length).map(accNames)
diff --git a/flink-table/flink-table-planner-blink/src/test/java/org/apache/flink/table/plan/util/JavaUserDefinedAggFunctions.java b/flink-table/flink-table-planner-blink/src/test/java/org/apache/flink/table/plan/util/JavaUserDefinedAggFunctions.java
deleted file mode 100644
index 5590771..0000000
--- a/flink-table/flink-table-planner-blink/src/test/java/org/apache/flink/table/plan/util/JavaUserDefinedAggFunctions.java
+++ /dev/null
@@ -1,120 +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.plan.util;
-
-import org.apache.flink.api.common.typeinfo.TypeInformation;
-import org.apache.flink.api.common.typeinfo.Types;
-import org.apache.flink.table.functions.AggregateFunction;
-
-/**
- * Test aggregator functions.
- */
-public class JavaUserDefinedAggFunctions {
-
-	/**
-	 * Accumulator of VarSumAggFunction.
-	 */
-	public static class VarSumAcc {
-		public long sum;
-	}
-
-	/**
-	 * Only used for test.
-	 */
-	public static class VarSumAggFunction extends AggregateFunction<Long, VarSumAcc> {
-
-		@Override
-		public VarSumAcc createAccumulator() {
-			return new VarSumAcc();
-		}
-
-		public void accumulate(VarSumAcc acc, Integer ...args) {
-			for (Integer x : args) {
-				if (x != null) {
-					acc.sum += x.longValue();
-				}
-			}
-		}
-
-		@Override
-		public Long getValue(VarSumAcc accumulator) {
-			return accumulator.sum;
-		}
-	}
-
-	/**
-	 * Only used for test.
-	 * The difference between the class and VarSumAggFunction is accumulator type.
-	 */
-	public static class VarSum1AggFunction extends AggregateFunction<Long, VarSumAcc> {
-
-		@Override
-		public VarSumAcc createAccumulator() {
-			return new VarSumAcc();
-		}
-
-		public void accumulate(VarSumAcc acc, Integer... args) {
-			for (Integer x : args) {
-				if (x != null) {
-					acc.sum += x.longValue();
-				}
-			}
-		}
-
-		@Override
-		public Long getValue(VarSumAcc accumulator) {
-			return accumulator.sum;
-		}
-
-		@Override
-		public TypeInformation<Long> getResultType() {
-			return Types.LONG;
-		}
-	}
-
-	/**
-	 * Only used for test.
-	 * The difference between the class and VarSumAggFunction is accumulator type.
-	 */
-	public static class VarSum2AggFunction extends AggregateFunction<Long, Long> {
-
-		@Override
-		public Long createAccumulator() {
-			return 0L;
-		}
-
-		public void accumulate(Long acc, Integer... args) {
-			for (Integer x : args) {
-				if (x != null) {
-					acc += x.longValue();
-				}
-			}
-		}
-
-		@Override
-		public Long getValue(Long accumulator) {
-			return accumulator;
-		}
-
-		@Override
-		public TypeInformation<Long> getResultType() {
-			return Types.LONG;
-		}
-	}
-}
diff --git a/flink-table/flink-table-planner-blink/src/test/resources/org/apache/flink/table/plan/batch/sql/HashAggregateTest.xml b/flink-table/flink-table-planner-blink/src/test/resources/org/apache/flink/table/plan/batch/sql/HashAggregateTest.xml
deleted file mode 100644
index 8196ab3..0000000
--- a/flink-table/flink-table-planner-blink/src/test/resources/org/apache/flink/table/plan/batch/sql/HashAggregateTest.xml
+++ /dev/null
@@ -1,1000 +0,0 @@
-<?xml version="1.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.
--->
-<Root>
-  <TestCase name="testAggNotSupportMerge[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT b, var_sum(a) FROM MyTable1 GROUP BY b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[var_sum($1)])
-+- LogicalProject(b=[$1], a=[$0])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], groupBy=[b], select=[b, var_sum(a) AS EXPR$1])
-+- Exchange(distribution=[hash[b]])
-   +- Calc(select=[b, a])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggNotSupportMerge[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT b, var_sum(a) FROM MyTable1 GROUP BY b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[var_sum($1)])
-+- LogicalProject(b=[$1], a=[$0])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], groupBy=[b], select=[b, var_sum(a) AS EXPR$1])
-+- Exchange(distribution=[hash[b]])
-   +- Calc(select=[b, a])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggNotSupportMerge[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT b, var_sum(a) FROM MyTable1 GROUP BY b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[var_sum($1)])
-+- LogicalProject(b=[$1], a=[$0])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], groupBy=[b], select=[b, var_sum(a) AS EXPR$1])
-+- Exchange(distribution=[hash[b]])
-   +- Calc(select=[b, a])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilter[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- LocalHashAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3])
-      +- Calc(select=[a, b, c], where=[=(a, 1)])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilter[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], select=[AVG(a) AS EXPR$0, SUM(b) AS EXPR$1, COUNT(c) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- Calc(select=[a, b, c], where=[=(a, 1)])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilter[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- LocalHashAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3])
-      +- Calc(select=[a, b, c], where=[=(a, 1)])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilterOnNestedFields[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c), SUM(c._1) FROM MyTable2 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)], EXPR$3=[SUM($3)])
-+- LogicalProject(a=[$0], b=[$1], c=[$2], $f3=[$2._1])
-   +- LogicalFilter(condition=[=($0, 1)])
-      +- LogicalTableScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2, Final_SUM(sum$4) AS EXPR$3])
-+- Exchange(distribution=[single])
-   +- LocalHashAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3, Partial_SUM($f3) AS sum$4])
-      +- Calc(select=[a, b, c, c._1 AS $f3], where=[=(a, 1)])
-         +- TableSourceScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilterOnNestedFields[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c), SUM(c._1) FROM MyTable2 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)], EXPR$3=[SUM($3)])
-+- LogicalProject(a=[$0], b=[$1], c=[$2], $f3=[$2._1])
-   +- LogicalFilter(condition=[=($0, 1)])
-      +- LogicalTableScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], select=[AVG(a) AS EXPR$0, SUM(b) AS EXPR$1, COUNT(c) AS EXPR$2, SUM($f3) AS EXPR$3])
-+- Exchange(distribution=[single])
-   +- Calc(select=[a, b, c, c._1 AS $f3], where=[=(a, 1)])
-      +- TableSourceScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilterOnNestedFields[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c), SUM(c._1) FROM MyTable2 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)], EXPR$3=[SUM($3)])
-+- LogicalProject(a=[$0], b=[$1], c=[$2], $f3=[$2._1])
-   +- LogicalFilter(condition=[=($0, 1)])
-      +- LogicalTableScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2, Final_SUM(sum$4) AS EXPR$3])
-+- Exchange(distribution=[single])
-   +- LocalHashAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3, Partial_SUM($f3) AS sum$4])
-      +- Calc(select=[a, b, c, c._1 AS $f3], where=[=(a, 1)])
-         +- TableSourceScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutFunction[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, b FROM MyTable1 GROUP BY a, b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0, 1}])
-+- LogicalProject(a=[$0], b=[$1])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], groupBy=[a, b], select=[a, b])
-+- Exchange(distribution=[hash[a, b]])
-   +- LocalHashAggregate(groupBy=[a, b], select=[a, b])
-      +- Calc(select=[a, b])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutFunction[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, b FROM MyTable1 GROUP BY a, b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0, 1}])
-+- LogicalProject(a=[$0], b=[$1])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], groupBy=[a, b], select=[a, b])
-+- Exchange(distribution=[hash[a, b]])
-   +- Calc(select=[a, b])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutFunction[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, b FROM MyTable1 GROUP BY a, b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0, 1}])
-+- LogicalProject(a=[$0], b=[$1])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], groupBy=[a, b], select=[a, b])
-+- Exchange(distribution=[hash[a, b]])
-   +- LocalHashAggregate(groupBy=[a, b], select=[a, b])
-      +- Calc(select=[a, b])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutGroupBy[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- LocalHashAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutGroupBy[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], select=[AVG(a) AS EXPR$0, SUM(b) AS EXPR$1, COUNT(c) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutGroupBy[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- LocalHashAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAvg[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT AVG(`byte`),
-       AVG(`short`),
-       AVG(`int`),
-       AVG(`long`),
-       AVG(`float`),
-       AVG(`double`),
-       AVG(`decimal3020`),
-       AVG(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[AVG($1)], EXPR$2=[AVG($2)], EXPR$3=[AVG($3)], EXPR$4=[AVG($4)], EXPR$5=[AVG($5)], EXPR$6=[AVG($6)], EXPR$7=[AVG($7)]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_AVG(sum$2, count$3) AS EXPR$1, Final_AVG(sum$4, count$5) AS EXPR$2, Final_AVG(sum$6, count$7) AS EXPR$3, Final_AVG(sum$8, count$9) AS EXPR$4, Final_AVG(sum$10, count$11) AS EXPR$5, Final_AVG(sum$12, count$13) AS EXPR$6, Final_AVG(sum$14, count$15) AS EXPR$7]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT sum$0, BIGINT count$1, BIGINT sum$2, BIGINT count$3, BIGINT sum$4, BIGINT count$5, BIGINT sum$6, BIGINT count$7, DOUBLE sum$8, BIGINT count$9, DOUBLE sum$10, BIGINT count$11, DECIMAL(38, 20) sum$12, BIGINT count$13, DECIMAL(38, 5) sum$14, BIGINT count$15)]
-   +- LocalHashAggregate(select=[Partial_AVG(byte) AS (sum$0, count$1), Partial_AVG(short) AS (sum$2, count$3), Partial_AVG(int) AS (sum$4, count$5), Partial_AVG(long) AS (sum$6, count$7), Partial_AVG(float) AS (sum$8, count$9), Partial_AVG(double) AS (sum$10, count$11), Partial_AVG(decimal3020) AS (sum$12, count$13), Partial_AVG(decimal105) AS (sum$14, count$15)]), rowType=[RecordType(BIGINT sum$0, BIGINT count$1, BIGINT sum$2, BIGINT count$3, BIGINT sum$4, BIGINT count$5, BIGINT sum$6, [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAvg[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT AVG(`byte`),
-       AVG(`short`),
-       AVG(`int`),
-       AVG(`long`),
-       AVG(`float`),
-       AVG(`double`),
-       AVG(`decimal3020`),
-       AVG(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[AVG($1)], EXPR$2=[AVG($2)], EXPR$3=[AVG($3)], EXPR$4=[AVG($4)], EXPR$5=[AVG($5)], EXPR$6=[AVG($6)], EXPR$7=[AVG($7)]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], select=[AVG(byte) AS EXPR$0, AVG(short) AS EXPR$1, AVG(int) AS EXPR$2, AVG(long) AS EXPR$3, AVG(float) AS EXPR$4, AVG(double) AS EXPR$5, AVG(decimal3020) AS EXPR$6, AVG(decimal105) AS EXPR$7]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAvg[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT AVG(`byte`),
-       AVG(`short`),
-       AVG(`int`),
-       AVG(`long`),
-       AVG(`float`),
-       AVG(`double`),
-       AVG(`decimal3020`),
-       AVG(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[AVG($1)], EXPR$2=[AVG($2)], EXPR$3=[AVG($3)], EXPR$4=[AVG($4)], EXPR$5=[AVG($5)], EXPR$6=[AVG($6)], EXPR$7=[AVG($7)]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_AVG(sum$2, count$3) AS EXPR$1, Final_AVG(sum$4, count$5) AS EXPR$2, Final_AVG(sum$6, count$7) AS EXPR$3, Final_AVG(sum$8, count$9) AS EXPR$4, Final_AVG(sum$10, count$11) AS EXPR$5, Final_AVG(sum$12, count$13) AS EXPR$6, Final_AVG(sum$14, count$15) AS EXPR$7]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT sum$0, BIGINT count$1, BIGINT sum$2, BIGINT count$3, BIGINT sum$4, BIGINT count$5, BIGINT sum$6, BIGINT count$7, DOUBLE sum$8, BIGINT count$9, DOUBLE sum$10, BIGINT count$11, DECIMAL(38, 20) sum$12, BIGINT count$13, DECIMAL(38, 5) sum$14, BIGINT count$15)]
-   +- LocalHashAggregate(select=[Partial_AVG(byte) AS (sum$0, count$1), Partial_AVG(short) AS (sum$2, count$3), Partial_AVG(int) AS (sum$4, count$5), Partial_AVG(long) AS (sum$6, count$7), Partial_AVG(float) AS (sum$8, count$9), Partial_AVG(double) AS (sum$10, count$11), Partial_AVG(decimal3020) AS (sum$12, count$13), Partial_AVG(decimal105) AS (sum$14, count$15)]), rowType=[RecordType(BIGINT sum$0, BIGINT count$1, BIGINT sum$2, BIGINT count$3, BIGINT sum$4, BIGINT count$5, BIGINT sum$6, [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCount[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT COUNT(`byte`),
-       COUNT(`short`),
-       COUNT(`int`),
-       COUNT(`long`),
-       COUNT(`float`),
-       COUNT(`double`),
-       COUNT(`decimal3020`),
-       COUNT(`decimal105`),
-       COUNT(`boolean`),
-       COUNT(`date`),
-       COUNT(`time`),
-       COUNT(`timestamp`),
-       COUNT(`string`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT($0)], EXPR$1=[COUNT($1)], EXPR$2=[COUNT($2)], EXPR$3=[COUNT($3)], EXPR$4=[COUNT($4)], EXPR$5=[COUNT($5)], EXPR$6=[COUNT($6)], EXPR$7=[COUNT($7)], EXPR$8=[COUNT($8)], EXPR$9=[COUNT($9)], EXPR$10=[COUNT($10)], EXPR$11=[COUNT($11)], EXPR$12=[COUNT($12)]), rowType=[RecordType(BIGINT EXPR$0, BIGINT EXPR$1, BIGINT EXPR$2, BIGINT EXPR$3, BIGINT EXPR$4, BIGINT EXPR$5, BIGINT EXPR$6, BIGINT EXPR$7, BIGINT EXPR$8, BIGINT EXPR$9, BIGINT EXPR$10, BIGINT EXP [...]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10], string=[$7]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_COUNT(count$0) AS EXPR$0, Final_COUNT(count$1) AS EXPR$1, Final_COUNT(count$2) AS EXPR$2, Final_COUNT(count$3) AS EXPR$3, Final_COUNT(count$4) AS EXPR$4, Final_COUNT(count$5) AS EXPR$5, Final_COUNT(count$6) AS EXPR$6, Final_COUNT(count$7) AS EXPR$7, Final_COUNT(count$8) AS EXPR$8, Final_COUNT(count$9) AS EXPR$9, Final_COUNT(count$10) AS EXPR$10, Final_COUNT(count$11) AS EXPR$11, Final_COUNT(count$12) AS EXPR$12]), rowType=[RecordType(BIGINT EXP [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT count$0, BIGINT count$1, BIGINT count$2, BIGINT count$3, BIGINT count$4, BIGINT count$5, BIGINT count$6, BIGINT count$7, BIGINT count$8, BIGINT count$9, BIGINT count$10, BIGINT count$11, BIGINT count$12)]
-   +- LocalHashAggregate(select=[Partial_COUNT(byte) AS count$0, Partial_COUNT(short) AS count$1, Partial_COUNT(int) AS count$2, Partial_COUNT(long) AS count$3, Partial_COUNT(float) AS count$4, Partial_COUNT(double) AS count$5, Partial_COUNT(decimal3020) AS count$6, Partial_COUNT(decimal105) AS count$7, Partial_COUNT(boolean) AS count$8, Partial_COUNT(date) AS count$9, Partial_COUNT(time) AS count$10, Partial_COUNT(timestamp) AS count$11, Partial_COUNT(string) AS count$12]), rowType=[Rec [...]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCount[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT COUNT(`byte`),
-       COUNT(`short`),
-       COUNT(`int`),
-       COUNT(`long`),
-       COUNT(`float`),
-       COUNT(`double`),
-       COUNT(`decimal3020`),
-       COUNT(`decimal105`),
-       COUNT(`boolean`),
-       COUNT(`date`),
-       COUNT(`time`),
-       COUNT(`timestamp`),
-       COUNT(`string`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT($0)], EXPR$1=[COUNT($1)], EXPR$2=[COUNT($2)], EXPR$3=[COUNT($3)], EXPR$4=[COUNT($4)], EXPR$5=[COUNT($5)], EXPR$6=[COUNT($6)], EXPR$7=[COUNT($7)], EXPR$8=[COUNT($8)], EXPR$9=[COUNT($9)], EXPR$10=[COUNT($10)], EXPR$11=[COUNT($11)], EXPR$12=[COUNT($12)]), rowType=[RecordType(BIGINT EXPR$0, BIGINT EXPR$1, BIGINT EXPR$2, BIGINT EXPR$3, BIGINT EXPR$4, BIGINT EXPR$5, BIGINT EXPR$6, BIGINT EXPR$7, BIGINT EXPR$8, BIGINT EXPR$9, BIGINT EXPR$10, BIGINT EXP [...]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10], string=[$7]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], select=[COUNT(byte) AS EXPR$0, COUNT(short) AS EXPR$1, COUNT(int) AS EXPR$2, COUNT(long) AS EXPR$3, COUNT(float) AS EXPR$4, COUNT(double) AS EXPR$5, COUNT(decimal3020) AS EXPR$6, COUNT(decimal105) AS EXPR$7, COUNT(boolean) AS EXPR$8, COUNT(date) AS EXPR$9, COUNT(time) AS EXPR$10, COUNT(timestamp) AS EXPR$11, COUNT(string) AS EXPR$12]), rowType=[RecordType(BIGINT EXPR$0, BIGINT EXPR$1, BIGINT EXPR$2, BIGINT EXPR$3, BIGINT EXPR$4, BIGINT EXPR$5, BIGINT EXPR$6 [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 2 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCount[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT COUNT(`byte`),
-       COUNT(`short`),
-       COUNT(`int`),
-       COUNT(`long`),
-       COUNT(`float`),
-       COUNT(`double`),
-       COUNT(`decimal3020`),
-       COUNT(`decimal105`),
-       COUNT(`boolean`),
-       COUNT(`date`),
-       COUNT(`time`),
-       COUNT(`timestamp`),
-       COUNT(`string`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT($0)], EXPR$1=[COUNT($1)], EXPR$2=[COUNT($2)], EXPR$3=[COUNT($3)], EXPR$4=[COUNT($4)], EXPR$5=[COUNT($5)], EXPR$6=[COUNT($6)], EXPR$7=[COUNT($7)], EXPR$8=[COUNT($8)], EXPR$9=[COUNT($9)], EXPR$10=[COUNT($10)], EXPR$11=[COUNT($11)], EXPR$12=[COUNT($12)]), rowType=[RecordType(BIGINT EXPR$0, BIGINT EXPR$1, BIGINT EXPR$2, BIGINT EXPR$3, BIGINT EXPR$4, BIGINT EXPR$5, BIGINT EXPR$6, BIGINT EXPR$7, BIGINT EXPR$8, BIGINT EXPR$9, BIGINT EXPR$10, BIGINT EXP [...]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10], string=[$7]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_COUNT(count$0) AS EXPR$0, Final_COUNT(count$1) AS EXPR$1, Final_COUNT(count$2) AS EXPR$2, Final_COUNT(count$3) AS EXPR$3, Final_COUNT(count$4) AS EXPR$4, Final_COUNT(count$5) AS EXPR$5, Final_COUNT(count$6) AS EXPR$6, Final_COUNT(count$7) AS EXPR$7, Final_COUNT(count$8) AS EXPR$8, Final_COUNT(count$9) AS EXPR$9, Final_COUNT(count$10) AS EXPR$10, Final_COUNT(count$11) AS EXPR$11, Final_COUNT(count$12) AS EXPR$12]), rowType=[RecordType(BIGINT EXP [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT count$0, BIGINT count$1, BIGINT count$2, BIGINT count$3, BIGINT count$4, BIGINT count$5, BIGINT count$6, BIGINT count$7, BIGINT count$8, BIGINT count$9, BIGINT count$10, BIGINT count$11, BIGINT count$12)]
-   +- LocalHashAggregate(select=[Partial_COUNT(byte) AS count$0, Partial_COUNT(short) AS count$1, Partial_COUNT(int) AS count$2, Partial_COUNT(long) AS count$3, Partial_COUNT(float) AS count$4, Partial_COUNT(double) AS count$5, Partial_COUNT(decimal3020) AS count$6, Partial_COUNT(decimal105) AS count$7, Partial_COUNT(boolean) AS count$8, Partial_COUNT(date) AS count$9, Partial_COUNT(time) AS count$10, Partial_COUNT(timestamp) AS count$11, Partial_COUNT(string) AS count$12]), rowType=[Rec [...]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregate[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), COUNT(c) FROM MyTable1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1, Final_COUNT(count$1) AS EXPR$2])
-+- Exchange(distribution=[hash[a]])
-   +- LocalHashAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0, Partial_COUNT(c) AS count$1])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCountStart[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT COUNT(*) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT()]), rowType=[RecordType(BIGINT EXPR$0)]
-+- LogicalProject($f0=[0]), rowType=[RecordType(INTEGER $f0)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_COUNT(count1$0) AS EXPR$0]), rowType=[RecordType(BIGINT EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT count1$0)]
-   +- LocalHashAggregate(select=[Partial_COUNT(*) AS count1$0]), rowType=[RecordType(BIGINT count1$0)]
-      +- Calc(select=[0 AS $f0]), rowType=[RecordType(INTEGER $f0)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCountStart[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT COUNT(*) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT()]), rowType=[RecordType(BIGINT EXPR$0)]
-+- LogicalProject($f0=[0]), rowType=[RecordType(INTEGER $f0)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], select=[COUNT(*) AS EXPR$0]), rowType=[RecordType(BIGINT EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(INTEGER $f0)]
-   +- Calc(select=[0 AS $f0]), rowType=[RecordType(INTEGER $f0)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCountStart[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT COUNT(*) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT()]), rowType=[RecordType(BIGINT EXPR$0)]
-+- LogicalProject($f0=[0]), rowType=[RecordType(INTEGER $f0)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_COUNT(count1$0) AS EXPR$0]), rowType=[RecordType(BIGINT EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT count1$0)]
-   +- LocalHashAggregate(select=[Partial_COUNT(*) AS count1$0]), rowType=[RecordType(BIGINT count1$0)]
-      +- Calc(select=[0 AS $f0]), rowType=[RecordType(INTEGER $f0)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregate[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), COUNT(c) FROM MyTable1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], groupBy=[a], select=[a, SUM(b) AS EXPR$1, COUNT(c) AS EXPR$2])
-+- Exchange(distribution=[hash[a]])
-   +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregate[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), COUNT(c) FROM MyTable1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1, Final_COUNT(count$1) AS EXPR$2])
-+- Exchange(distribution=[hash[a]])
-   +- LocalHashAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0, Partial_COUNT(c) AS count$1])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregateWithFilter[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), count(c) FROM MyTable1 WHERE a = 1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1, Final_COUNT(count$1) AS EXPR$2])
-+- Exchange(distribution=[hash[a]])
-   +- LocalHashAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0, Partial_COUNT(c) AS count$1])
-      +- Calc(select=[a, b, c], where=[=(a, 1)])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregateWithFilter[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), count(c) FROM MyTable1 WHERE a = 1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], groupBy=[a], select=[a, SUM(b) AS EXPR$1, COUNT(c) AS EXPR$2])
-+- Exchange(distribution=[hash[a]])
-   +- Calc(select=[a, b, c], where=[=(a, 1)])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregateWithFilter[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), count(c) FROM MyTable1 WHERE a = 1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1, Final_COUNT(count$1) AS EXPR$2])
-+- Exchange(distribution=[hash[a]])
-   +- LocalHashAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0, Partial_COUNT(c) AS count$1])
-      +- Calc(select=[a, b, c], where=[=(a, 1)])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMaxWithFixLengthType[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MAX(`byte`),
-       MAX(`short`),
-       MAX(`int`),
-       MAX(`long`),
-       MAX(`float`),
-       MAX(`double`),
-       MAX(`decimal3020`),
-       MAX(`decimal105`),
-       MAX(`boolean`),
-       MAX(`date`),
-       MAX(`time`),
-       MAX(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MAX($0)], EXPR$1=[MAX($1)], EXPR$2=[MAX($2)], EXPR$3=[MAX($3)], EXPR$4=[MAX($4)], EXPR$5=[MAX($5)], EXPR$6=[MAX($6)], EXPR$7=[MAX($7)], EXPR$8=[MAX($8)], EXPR$9=[MAX($9)], EXPR$10=[MAX($10)], EXPR$11=[MAX($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_MAX(max$0) AS EXPR$0, Final_MAX(max$1) AS EXPR$1, Final_MAX(max$2) AS EXPR$2, Final_MAX(max$3) AS EXPR$3, Final_MAX(max$4) AS EXPR$4, Final_MAX(max$5) AS EXPR$5, Final_MAX(max$6) AS EXPR$6, Final_MAX(max$7) AS EXPR$7, Final_MAX(max$8) AS EXPR$8, Final_MAX(max$9) AS EXPR$9, Final_MAX(max$10) AS EXPR$10, Final_MAX(max$11) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT max$0, SMALLINT max$1, INTEGER max$2, BIGINT max$3, FLOAT max$4, DOUBLE max$5, DECIMAL(30, 20) max$6, DECIMAL(10, 5) max$7, BOOLEAN max$8, INTEGER max$9, INTEGER max$10, BIGINT max$11)]
-   +- LocalHashAggregate(select=[Partial_MAX(byte) AS max$0, Partial_MAX(short) AS max$1, Partial_MAX(int) AS max$2, Partial_MAX(long) AS max$3, Partial_MAX(float) AS max$4, Partial_MAX(double) AS max$5, Partial_MAX(decimal3020) AS max$6, Partial_MAX(decimal105) AS max$7, Partial_MAX(boolean) AS max$8, Partial_MAX(date) AS max$9, Partial_MAX(time) AS max$10, Partial_MAX(timestamp) AS max$11]), rowType=[RecordType(TINYINT max$0, SMALLINT max$1, INTEGER max$2, BIGINT max$3, FLOAT max$4, DO [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMaxWithFixLengthType[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MAX(`byte`),
-       MAX(`short`),
-       MAX(`int`),
-       MAX(`long`),
-       MAX(`float`),
-       MAX(`double`),
-       MAX(`decimal3020`),
-       MAX(`decimal105`),
-       MAX(`boolean`),
-       MAX(`date`),
-       MAX(`time`),
-       MAX(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MAX($0)], EXPR$1=[MAX($1)], EXPR$2=[MAX($2)], EXPR$3=[MAX($3)], EXPR$4=[MAX($4)], EXPR$5=[MAX($5)], EXPR$6=[MAX($6)], EXPR$7=[MAX($7)], EXPR$8=[MAX($8)], EXPR$9=[MAX($9)], EXPR$10=[MAX($10)], EXPR$11=[MAX($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], select=[MAX(byte) AS EXPR$0, MAX(short) AS EXPR$1, MAX(int) AS EXPR$2, MAX(long) AS EXPR$3, MAX(float) AS EXPR$4, MAX(double) AS EXPR$5, MAX(decimal3020) AS EXPR$6, MAX(decimal105) AS EXPR$7, MAX(boolean) AS EXPR$8, MAX(date) AS EXPR$9, MAX(time) AS EXPR$10, MAX(timestamp) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$ [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMaxWithFixLengthType[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MAX(`byte`),
-       MAX(`short`),
-       MAX(`int`),
-       MAX(`long`),
-       MAX(`float`),
-       MAX(`double`),
-       MAX(`decimal3020`),
-       MAX(`decimal105`),
-       MAX(`boolean`),
-       MAX(`date`),
-       MAX(`time`),
-       MAX(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MAX($0)], EXPR$1=[MAX($1)], EXPR$2=[MAX($2)], EXPR$3=[MAX($3)], EXPR$4=[MAX($4)], EXPR$5=[MAX($5)], EXPR$6=[MAX($6)], EXPR$7=[MAX($7)], EXPR$8=[MAX($8)], EXPR$9=[MAX($9)], EXPR$10=[MAX($10)], EXPR$11=[MAX($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_MAX(max$0) AS EXPR$0, Final_MAX(max$1) AS EXPR$1, Final_MAX(max$2) AS EXPR$2, Final_MAX(max$3) AS EXPR$3, Final_MAX(max$4) AS EXPR$4, Final_MAX(max$5) AS EXPR$5, Final_MAX(max$6) AS EXPR$6, Final_MAX(max$7) AS EXPR$7, Final_MAX(max$8) AS EXPR$8, Final_MAX(max$9) AS EXPR$9, Final_MAX(max$10) AS EXPR$10, Final_MAX(max$11) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT max$0, SMALLINT max$1, INTEGER max$2, BIGINT max$3, FLOAT max$4, DOUBLE max$5, DECIMAL(30, 20) max$6, DECIMAL(10, 5) max$7, BOOLEAN max$8, INTEGER max$9, INTEGER max$10, BIGINT max$11)]
-   +- LocalHashAggregate(select=[Partial_MAX(byte) AS max$0, Partial_MAX(short) AS max$1, Partial_MAX(int) AS max$2, Partial_MAX(long) AS max$3, Partial_MAX(float) AS max$4, Partial_MAX(double) AS max$5, Partial_MAX(decimal3020) AS max$6, Partial_MAX(decimal105) AS max$7, Partial_MAX(boolean) AS max$8, Partial_MAX(date) AS max$9, Partial_MAX(time) AS max$10, Partial_MAX(timestamp) AS max$11]), rowType=[RecordType(TINYINT max$0, SMALLINT max$1, INTEGER max$2, BIGINT max$3, FLOAT max$4, DO [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testSum[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT SUM(`byte`),
-       SUM(`short`),
-       SUM(`int`),
-       SUM(`long`),
-       SUM(`float`),
-       SUM(`double`),
-       SUM(`decimal3020`),
-       SUM(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[SUM($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(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_SUM(sum$0) AS EXPR$0, Final_SUM(sum$1) AS EXPR$1, Final_SUM(sum$2) AS EXPR$2, Final_SUM(sum$3) AS EXPR$3, Final_SUM(sum$4) AS EXPR$4, Final_SUM(sum$5) AS EXPR$5, Final_SUM(sum$6) AS EXPR$6, Final_SUM(sum$7) AS EXPR$7]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT sum$0, SMALLINT sum$1, INTEGER sum$2, BIGINT sum$3, FLOAT sum$4, DOUBLE sum$5, DECIMAL(38, 20) sum$6, DECIMAL(38, 5) sum$7)]
-   +- LocalHashAggregate(select=[Partial_SUM(byte) AS sum$0, Partial_SUM(short) AS sum$1, Partial_SUM(int) AS sum$2, Partial_SUM(long) AS sum$3, Partial_SUM(float) AS sum$4, Partial_SUM(double) AS sum$5, Partial_SUM(decimal3020) AS sum$6, Partial_SUM(decimal105) AS sum$7]), rowType=[RecordType(TINYINT sum$0, SMALLINT sum$1, INTEGER sum$2, BIGINT sum$3, FLOAT sum$4, DOUBLE sum$5, DECIMAL(38, 20) sum$6, DECIMAL(38, 5) sum$7)]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMinWithFixLengthType[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MIN(`byte`),
-       MIN(`short`),
-       MIN(`int`),
-       MIN(`long`),
-       MIN(`float`),
-       MIN(`double`),
-       MIN(`decimal3020`),
-       MIN(`decimal105`),
-       MIN(`boolean`),
-       MIN(`date`),
-       MIN(`time`),
-       MIN(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MIN($0)], EXPR$1=[MIN($1)], EXPR$2=[MIN($2)], EXPR$3=[MIN($3)], EXPR$4=[MIN($4)], EXPR$5=[MIN($5)], EXPR$6=[MIN($6)], EXPR$7=[MIN($7)], EXPR$8=[MIN($8)], EXPR$9=[MIN($9)], EXPR$10=[MIN($10)], EXPR$11=[MIN($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_MIN(min$0) AS EXPR$0, Final_MIN(min$1) AS EXPR$1, Final_MIN(min$2) AS EXPR$2, Final_MIN(min$3) AS EXPR$3, Final_MIN(min$4) AS EXPR$4, Final_MIN(min$5) AS EXPR$5, Final_MIN(min$6) AS EXPR$6, Final_MIN(min$7) AS EXPR$7, Final_MIN(min$8) AS EXPR$8, Final_MIN(min$9) AS EXPR$9, Final_MIN(min$10) AS EXPR$10, Final_MIN(min$11) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT min$0, SMALLINT min$1, INTEGER min$2, BIGINT min$3, FLOAT min$4, DOUBLE min$5, DECIMAL(30, 20) min$6, DECIMAL(10, 5) min$7, BOOLEAN min$8, INTEGER min$9, INTEGER min$10, BIGINT min$11)]
-   +- LocalHashAggregate(select=[Partial_MIN(byte) AS min$0, Partial_MIN(short) AS min$1, Partial_MIN(int) AS min$2, Partial_MIN(long) AS min$3, Partial_MIN(float) AS min$4, Partial_MIN(double) AS min$5, Partial_MIN(decimal3020) AS min$6, Partial_MIN(decimal105) AS min$7, Partial_MIN(boolean) AS min$8, Partial_MIN(date) AS min$9, Partial_MIN(time) AS min$10, Partial_MIN(timestamp) AS min$11]), rowType=[RecordType(TINYINT min$0, SMALLINT min$1, INTEGER min$2, BIGINT min$3, FLOAT min$4, DO [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMinWithFixLengthType[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MIN(`byte`),
-       MIN(`short`),
-       MIN(`int`),
-       MIN(`long`),
-       MIN(`float`),
-       MIN(`double`),
-       MIN(`decimal3020`),
-       MIN(`decimal105`),
-       MIN(`boolean`),
-       MIN(`date`),
-       MIN(`time`),
-       MIN(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MIN($0)], EXPR$1=[MIN($1)], EXPR$2=[MIN($2)], EXPR$3=[MIN($3)], EXPR$4=[MIN($4)], EXPR$5=[MIN($5)], EXPR$6=[MIN($6)], EXPR$7=[MIN($7)], EXPR$8=[MIN($8)], EXPR$9=[MIN($9)], EXPR$10=[MIN($10)], EXPR$11=[MIN($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_MIN(min$0) AS EXPR$0, Final_MIN(min$1) AS EXPR$1, Final_MIN(min$2) AS EXPR$2, Final_MIN(min$3) AS EXPR$3, Final_MIN(min$4) AS EXPR$4, Final_MIN(min$5) AS EXPR$5, Final_MIN(min$6) AS EXPR$6, Final_MIN(min$7) AS EXPR$7, Final_MIN(min$8) AS EXPR$8, Final_MIN(min$9) AS EXPR$9, Final_MIN(min$10) AS EXPR$10, Final_MIN(min$11) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT min$0, SMALLINT min$1, INTEGER min$2, BIGINT min$3, FLOAT min$4, DOUBLE min$5, DECIMAL(30, 20) min$6, DECIMAL(10, 5) min$7, BOOLEAN min$8, INTEGER min$9, INTEGER min$10, BIGINT min$11)]
-   +- LocalHashAggregate(select=[Partial_MIN(byte) AS min$0, Partial_MIN(short) AS min$1, Partial_MIN(int) AS min$2, Partial_MIN(long) AS min$3, Partial_MIN(float) AS min$4, Partial_MIN(double) AS min$5, Partial_MIN(decimal3020) AS min$6, Partial_MIN(decimal105) AS min$7, Partial_MIN(boolean) AS min$8, Partial_MIN(date) AS min$9, Partial_MIN(time) AS min$10, Partial_MIN(timestamp) AS min$11]), rowType=[RecordType(TINYINT min$0, SMALLINT min$1, INTEGER min$2, BIGINT min$3, FLOAT min$4, DO [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testSum[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT SUM(`byte`),
-       SUM(`short`),
-       SUM(`int`),
-       SUM(`long`),
-       SUM(`float`),
-       SUM(`double`),
-       SUM(`decimal3020`),
-       SUM(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[SUM($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(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], select=[SUM(byte) AS EXPR$0, SUM(short) AS EXPR$1, SUM(int) AS EXPR$2, SUM(long) AS EXPR$3, SUM(float) AS EXPR$4, SUM(double) AS EXPR$5, SUM(decimal3020) AS EXPR$6, SUM(decimal105) AS EXPR$7]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMinWithFixLengthType[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MIN(`byte`),
-       MIN(`short`),
-       MIN(`int`),
-       MIN(`long`),
-       MIN(`float`),
-       MIN(`double`),
-       MIN(`decimal3020`),
-       MIN(`decimal105`),
-       MIN(`boolean`),
-       MIN(`date`),
-       MIN(`time`),
-       MIN(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MIN($0)], EXPR$1=[MIN($1)], EXPR$2=[MIN($2)], EXPR$3=[MIN($3)], EXPR$4=[MIN($4)], EXPR$5=[MIN($5)], EXPR$6=[MIN($6)], EXPR$7=[MIN($7)], EXPR$8=[MIN($8)], EXPR$9=[MIN($9)], EXPR$10=[MIN($10)], EXPR$11=[MIN($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[false], select=[MIN(byte) AS EXPR$0, MIN(short) AS EXPR$1, MIN(int) AS EXPR$2, MIN(long) AS EXPR$3, MIN(float) AS EXPR$4, MIN(double) AS EXPR$5, MIN(decimal3020) AS EXPR$6, MIN(decimal105) AS EXPR$7, MIN(boolean) AS EXPR$8, MIN(date) AS EXPR$9, MIN(time) AS EXPR$10, MIN(timestamp) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$ [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testSum[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT SUM(`byte`),
-       SUM(`short`),
-       SUM(`int`),
-       SUM(`long`),
-       SUM(`float`),
-       SUM(`double`),
-       SUM(`decimal3020`),
-       SUM(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[SUM($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(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashAggregate(isMerge=[true], select=[Final_SUM(sum$0) AS EXPR$0, Final_SUM(sum$1) AS EXPR$1, Final_SUM(sum$2) AS EXPR$2, Final_SUM(sum$3) AS EXPR$3, Final_SUM(sum$4) AS EXPR$4, Final_SUM(sum$5) AS EXPR$5, Final_SUM(sum$6) AS EXPR$6, Final_SUM(sum$7) AS EXPR$7]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT sum$0, SMALLINT sum$1, INTEGER sum$2, BIGINT sum$3, FLOAT sum$4, DOUBLE sum$5, DECIMAL(38, 20) sum$6, DECIMAL(38, 5) sum$7)]
-   +- LocalHashAggregate(select=[Partial_SUM(byte) AS sum$0, Partial_SUM(short) AS sum$1, Partial_SUM(int) AS sum$2, Partial_SUM(long) AS sum$3, Partial_SUM(float) AS sum$4, Partial_SUM(double) AS sum$5, Partial_SUM(decimal3020) AS sum$6, Partial_SUM(decimal105) AS sum$7]), rowType=[RecordType(TINYINT sum$0, SMALLINT sum$1, INTEGER sum$2, BIGINT sum$3, FLOAT sum$4, DOUBLE sum$5, DECIMAL(38, 20) sum$6, DECIMAL(38, 5) sum$7)]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-</Root>
diff --git a/flink-table/flink-table-planner-blink/src/test/resources/org/apache/flink/table/plan/batch/sql/SortAggregateTest.xml b/flink-table/flink-table-planner-blink/src/test/resources/org/apache/flink/table/plan/batch/sql/SortAggregateTest.xml
deleted file mode 100644
index cd1acd7..0000000
--- a/flink-table/flink-table-planner-blink/src/test/resources/org/apache/flink/table/plan/batch/sql/SortAggregateTest.xml
+++ /dev/null
@@ -1,1205 +0,0 @@
-<?xml version="1.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.
--->
-<Root>
-  <TestCase name="testAggNotSupportMerge[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT b, var_sum(a) FROM MyTable1 GROUP BY b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[var_sum($1)])
-+- LogicalProject(b=[$1], a=[$0])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], groupBy=[b], select=[b, var_sum(a) AS EXPR$1])
-+- Sort(orderBy=[b ASC])
-   +- Exchange(distribution=[hash[b]])
-      +- Calc(select=[b, a])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggNotSupportMerge[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT b, var_sum(a) FROM MyTable1 GROUP BY b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[var_sum($1)])
-+- LogicalProject(b=[$1], a=[$0])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], groupBy=[b], select=[b, var_sum(a) AS EXPR$1])
-+- Sort(orderBy=[b ASC])
-   +- Exchange(distribution=[hash[b]])
-      +- Calc(select=[b, a])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggNotSupportMerge[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT b, var_sum(a) FROM MyTable1 GROUP BY b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[var_sum($1)])
-+- LogicalProject(b=[$1], a=[$0])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], groupBy=[b], select=[b, var_sum(a) AS EXPR$1])
-+- Sort(orderBy=[b ASC])
-   +- Exchange(distribution=[hash[b]])
-      +- Calc(select=[b, a])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilter[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- LocalSortAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3])
-      +- Calc(select=[a, b, c], where=[=(a, 1)])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilter[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], select=[AVG(a) AS EXPR$0, SUM(b) AS EXPR$1, COUNT(c) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- Calc(select=[a, b, c], where=[=(a, 1)])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilter[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- LocalSortAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3])
-      +- Calc(select=[a, b, c], where=[=(a, 1)])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilterOnNestedFields[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c), SUM(c._1) FROM MyTable2 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)], EXPR$3=[SUM($3)])
-+- LogicalProject(a=[$0], b=[$1], c=[$2], $f3=[$2._1])
-   +- LogicalFilter(condition=[=($0, 1)])
-      +- LogicalTableScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2, Final_SUM(sum$4) AS EXPR$3])
-+- Exchange(distribution=[single])
-   +- LocalSortAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3, Partial_SUM($f3) AS sum$4])
-      +- Calc(select=[a, b, c, c._1 AS $f3], where=[=(a, 1)])
-         +- TableSourceScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilterOnNestedFields[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c), SUM(c._1) FROM MyTable2 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)], EXPR$3=[SUM($3)])
-+- LogicalProject(a=[$0], b=[$1], c=[$2], $f3=[$2._1])
-   +- LogicalFilter(condition=[=($0, 1)])
-      +- LogicalTableScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], select=[AVG(a) AS EXPR$0, SUM(b) AS EXPR$1, COUNT(c) AS EXPR$2, SUM($f3) AS EXPR$3])
-+- Exchange(distribution=[single])
-   +- Calc(select=[a, b, c, c._1 AS $f3], where=[=(a, 1)])
-      +- TableSourceScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithFilterOnNestedFields[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c), SUM(c._1) FROM MyTable2 WHERE a = 1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)], EXPR$3=[SUM($3)])
-+- LogicalProject(a=[$0], b=[$1], c=[$2], $f3=[$2._1])
-   +- LogicalFilter(condition=[=($0, 1)])
-      +- LogicalTableScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2, Final_SUM(sum$4) AS EXPR$3])
-+- Exchange(distribution=[single])
-   +- LocalSortAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3, Partial_SUM($f3) AS sum$4])
-      +- Calc(select=[a, b, c, c._1 AS $f3], where=[=(a, 1)])
-         +- TableSourceScan(table=[[MyTable2, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutFunction[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, b FROM MyTable1 GROUP BY a, b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0, 1}])
-+- LogicalProject(a=[$0], b=[$1])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], groupBy=[a, b], select=[a, b])
-+- Sort(orderBy=[a ASC, b ASC])
-   +- Exchange(distribution=[hash[a, b]])
-      +- LocalSortAggregate(groupBy=[a, b], select=[a, b])
-         +- Sort(orderBy=[a ASC, b ASC])
-            +- Calc(select=[a, b])
-               +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutFunction[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, b FROM MyTable1 GROUP BY a, b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0, 1}])
-+- LogicalProject(a=[$0], b=[$1])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], groupBy=[a, b], select=[a, b])
-+- Sort(orderBy=[a ASC, b ASC])
-   +- Exchange(distribution=[hash[a, b]])
-      +- Calc(select=[a, b])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutFunction[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, b FROM MyTable1 GROUP BY a, b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0, 1}])
-+- LogicalProject(a=[$0], b=[$1])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], groupBy=[a, b], select=[a, b])
-+- Sort(orderBy=[a ASC, b ASC])
-   +- Exchange(distribution=[hash[a, b]])
-      +- LocalSortAggregate(groupBy=[a, b], select=[a, b])
-         +- Sort(orderBy=[a ASC, b ASC])
-            +- Calc(select=[a, b])
-               +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutGroupBy[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- LocalSortAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutGroupBy[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], select=[AVG(a) AS EXPR$0, SUM(b) AS EXPR$1, COUNT(c) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAggregateWithoutGroupBy[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_SUM(sum$2) AS EXPR$1, Final_COUNT(count$3) AS EXPR$2])
-+- Exchange(distribution=[single])
-   +- LocalSortAggregate(select=[Partial_AVG(a) AS (sum$0, count$1), Partial_SUM(b) AS sum$2, Partial_COUNT(c) AS count$3])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAvg[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT AVG(`byte`),
-       AVG(`short`),
-       AVG(`int`),
-       AVG(`long`),
-       AVG(`float`),
-       AVG(`double`),
-       AVG(`decimal3020`),
-       AVG(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[AVG($1)], EXPR$2=[AVG($2)], EXPR$3=[AVG($3)], EXPR$4=[AVG($4)], EXPR$5=[AVG($5)], EXPR$6=[AVG($6)], EXPR$7=[AVG($7)]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_AVG(sum$2, count$3) AS EXPR$1, Final_AVG(sum$4, count$5) AS EXPR$2, Final_AVG(sum$6, count$7) AS EXPR$3, Final_AVG(sum$8, count$9) AS EXPR$4, Final_AVG(sum$10, count$11) AS EXPR$5, Final_AVG(sum$12, count$13) AS EXPR$6, Final_AVG(sum$14, count$15) AS EXPR$7]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT sum$0, BIGINT count$1, BIGINT sum$2, BIGINT count$3, BIGINT sum$4, BIGINT count$5, BIGINT sum$6, BIGINT count$7, DOUBLE sum$8, BIGINT count$9, DOUBLE sum$10, BIGINT count$11, DECIMAL(38, 20) sum$12, BIGINT count$13, DECIMAL(38, 5) sum$14, BIGINT count$15)]
-   +- LocalSortAggregate(select=[Partial_AVG(byte) AS (sum$0, count$1), Partial_AVG(short) AS (sum$2, count$3), Partial_AVG(int) AS (sum$4, count$5), Partial_AVG(long) AS (sum$6, count$7), Partial_AVG(float) AS (sum$8, count$9), Partial_AVG(double) AS (sum$10, count$11), Partial_AVG(decimal3020) AS (sum$12, count$13), Partial_AVG(decimal105) AS (sum$14, count$15)]), rowType=[RecordType(BIGINT sum$0, BIGINT count$1, BIGINT sum$2, BIGINT count$3, BIGINT sum$4, BIGINT count$5, BIGINT sum$6, [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAvg[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT AVG(`byte`),
-       AVG(`short`),
-       AVG(`int`),
-       AVG(`long`),
-       AVG(`float`),
-       AVG(`double`),
-       AVG(`decimal3020`),
-       AVG(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[AVG($1)], EXPR$2=[AVG($2)], EXPR$3=[AVG($3)], EXPR$4=[AVG($4)], EXPR$5=[AVG($5)], EXPR$6=[AVG($6)], EXPR$7=[AVG($7)]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], select=[AVG(byte) AS EXPR$0, AVG(short) AS EXPR$1, AVG(int) AS EXPR$2, AVG(long) AS EXPR$3, AVG(float) AS EXPR$4, AVG(double) AS EXPR$5, AVG(decimal3020) AS EXPR$6, AVG(decimal105) AS EXPR$7]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testAvg[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT AVG(`byte`),
-       AVG(`short`),
-       AVG(`int`),
-       AVG(`long`),
-       AVG(`float`),
-       AVG(`double`),
-       AVG(`decimal3020`),
-       AVG(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], EXPR$1=[AVG($1)], EXPR$2=[AVG($2)], EXPR$3=[AVG($3)], EXPR$4=[AVG($4)], EXPR$5=[AVG($5)], EXPR$6=[AVG($6)], EXPR$7=[AVG($7)]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_AVG(sum$0, count$1) AS EXPR$0, Final_AVG(sum$2, count$3) AS EXPR$1, Final_AVG(sum$4, count$5) AS EXPR$2, Final_AVG(sum$6, count$7) AS EXPR$3, Final_AVG(sum$8, count$9) AS EXPR$4, Final_AVG(sum$10, count$11) AS EXPR$5, Final_AVG(sum$12, count$13) AS EXPR$6, Final_AVG(sum$14, count$15) AS EXPR$7]), rowType=[RecordType(DOUBLE EXPR$0, DOUBLE EXPR$1, DOUBLE EXPR$2, DOUBLE EXPR$3, DOUBLE EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 6) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT sum$0, BIGINT count$1, BIGINT sum$2, BIGINT count$3, BIGINT sum$4, BIGINT count$5, BIGINT sum$6, BIGINT count$7, DOUBLE sum$8, BIGINT count$9, DOUBLE sum$10, BIGINT count$11, DECIMAL(38, 20) sum$12, BIGINT count$13, DECIMAL(38, 5) sum$14, BIGINT count$15)]
-   +- LocalSortAggregate(select=[Partial_AVG(byte) AS (sum$0, count$1), Partial_AVG(short) AS (sum$2, count$3), Partial_AVG(int) AS (sum$4, count$5), Partial_AVG(long) AS (sum$6, count$7), Partial_AVG(float) AS (sum$8, count$9), Partial_AVG(double) AS (sum$10, count$11), Partial_AVG(decimal3020) AS (sum$12, count$13), Partial_AVG(decimal105) AS (sum$14, count$15)]), rowType=[RecordType(BIGINT sum$0, BIGINT count$1, BIGINT sum$2, BIGINT count$3, BIGINT sum$4, BIGINT count$5, BIGINT sum$6, [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCount[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT COUNT(`byte`),
-       COUNT(`short`),
-       COUNT(`int`),
-       COUNT(`long`),
-       COUNT(`float`),
-       COUNT(`double`),
-       COUNT(`decimal3020`),
-       COUNT(`decimal105`),
-       COUNT(`boolean`),
-       COUNT(`date`),
-       COUNT(`time`),
-       COUNT(`timestamp`),
-       COUNT(`string`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT($0)], EXPR$1=[COUNT($1)], EXPR$2=[COUNT($2)], EXPR$3=[COUNT($3)], EXPR$4=[COUNT($4)], EXPR$5=[COUNT($5)], EXPR$6=[COUNT($6)], EXPR$7=[COUNT($7)], EXPR$8=[COUNT($8)], EXPR$9=[COUNT($9)], EXPR$10=[COUNT($10)], EXPR$11=[COUNT($11)], EXPR$12=[COUNT($12)]), rowType=[RecordType(BIGINT EXPR$0, BIGINT EXPR$1, BIGINT EXPR$2, BIGINT EXPR$3, BIGINT EXPR$4, BIGINT EXPR$5, BIGINT EXPR$6, BIGINT EXPR$7, BIGINT EXPR$8, BIGINT EXPR$9, BIGINT EXPR$10, BIGINT EXP [...]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10], string=[$7]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_COUNT(count$0) AS EXPR$0, Final_COUNT(count$1) AS EXPR$1, Final_COUNT(count$2) AS EXPR$2, Final_COUNT(count$3) AS EXPR$3, Final_COUNT(count$4) AS EXPR$4, Final_COUNT(count$5) AS EXPR$5, Final_COUNT(count$6) AS EXPR$6, Final_COUNT(count$7) AS EXPR$7, Final_COUNT(count$8) AS EXPR$8, Final_COUNT(count$9) AS EXPR$9, Final_COUNT(count$10) AS EXPR$10, Final_COUNT(count$11) AS EXPR$11, Final_COUNT(count$12) AS EXPR$12]), rowType=[RecordType(BIGINT EXP [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT count$0, BIGINT count$1, BIGINT count$2, BIGINT count$3, BIGINT count$4, BIGINT count$5, BIGINT count$6, BIGINT count$7, BIGINT count$8, BIGINT count$9, BIGINT count$10, BIGINT count$11, BIGINT count$12)]
-   +- LocalSortAggregate(select=[Partial_COUNT(byte) AS count$0, Partial_COUNT(short) AS count$1, Partial_COUNT(int) AS count$2, Partial_COUNT(long) AS count$3, Partial_COUNT(float) AS count$4, Partial_COUNT(double) AS count$5, Partial_COUNT(decimal3020) AS count$6, Partial_COUNT(decimal105) AS count$7, Partial_COUNT(boolean) AS count$8, Partial_COUNT(date) AS count$9, Partial_COUNT(time) AS count$10, Partial_COUNT(timestamp) AS count$11, Partial_COUNT(string) AS count$12]), rowType=[Rec [...]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCount[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT COUNT(`byte`),
-       COUNT(`short`),
-       COUNT(`int`),
-       COUNT(`long`),
-       COUNT(`float`),
-       COUNT(`double`),
-       COUNT(`decimal3020`),
-       COUNT(`decimal105`),
-       COUNT(`boolean`),
-       COUNT(`date`),
-       COUNT(`time`),
-       COUNT(`timestamp`),
-       COUNT(`string`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT($0)], EXPR$1=[COUNT($1)], EXPR$2=[COUNT($2)], EXPR$3=[COUNT($3)], EXPR$4=[COUNT($4)], EXPR$5=[COUNT($5)], EXPR$6=[COUNT($6)], EXPR$7=[COUNT($7)], EXPR$8=[COUNT($8)], EXPR$9=[COUNT($9)], EXPR$10=[COUNT($10)], EXPR$11=[COUNT($11)], EXPR$12=[COUNT($12)]), rowType=[RecordType(BIGINT EXPR$0, BIGINT EXPR$1, BIGINT EXPR$2, BIGINT EXPR$3, BIGINT EXPR$4, BIGINT EXPR$5, BIGINT EXPR$6, BIGINT EXPR$7, BIGINT EXPR$8, BIGINT EXPR$9, BIGINT EXPR$10, BIGINT EXP [...]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10], string=[$7]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], select=[COUNT(byte) AS EXPR$0, COUNT(short) AS EXPR$1, COUNT(int) AS EXPR$2, COUNT(long) AS EXPR$3, COUNT(float) AS EXPR$4, COUNT(double) AS EXPR$5, COUNT(decimal3020) AS EXPR$6, COUNT(decimal105) AS EXPR$7, COUNT(boolean) AS EXPR$8, COUNT(date) AS EXPR$9, COUNT(time) AS EXPR$10, COUNT(timestamp) AS EXPR$11, COUNT(string) AS EXPR$12]), rowType=[RecordType(BIGINT EXPR$0, BIGINT EXPR$1, BIGINT EXPR$2, BIGINT EXPR$3, BIGINT EXPR$4, BIGINT EXPR$5, BIGINT EXPR$6 [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 2 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCount[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT COUNT(`byte`),
-       COUNT(`short`),
-       COUNT(`int`),
-       COUNT(`long`),
-       COUNT(`float`),
-       COUNT(`double`),
-       COUNT(`decimal3020`),
-       COUNT(`decimal105`),
-       COUNT(`boolean`),
-       COUNT(`date`),
-       COUNT(`time`),
-       COUNT(`timestamp`),
-       COUNT(`string`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT($0)], EXPR$1=[COUNT($1)], EXPR$2=[COUNT($2)], EXPR$3=[COUNT($3)], EXPR$4=[COUNT($4)], EXPR$5=[COUNT($5)], EXPR$6=[COUNT($6)], EXPR$7=[COUNT($7)], EXPR$8=[COUNT($8)], EXPR$9=[COUNT($9)], EXPR$10=[COUNT($10)], EXPR$11=[COUNT($11)], EXPR$12=[COUNT($12)]), rowType=[RecordType(BIGINT EXPR$0, BIGINT EXPR$1, BIGINT EXPR$2, BIGINT EXPR$3, BIGINT EXPR$4, BIGINT EXPR$5, BIGINT EXPR$6, BIGINT EXPR$7, BIGINT EXPR$8, BIGINT EXPR$9, BIGINT EXPR$10, BIGINT EXP [...]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10], string=[$7]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_COUNT(count$0) AS EXPR$0, Final_COUNT(count$1) AS EXPR$1, Final_COUNT(count$2) AS EXPR$2, Final_COUNT(count$3) AS EXPR$3, Final_COUNT(count$4) AS EXPR$4, Final_COUNT(count$5) AS EXPR$5, Final_COUNT(count$6) AS EXPR$6, Final_COUNT(count$7) AS EXPR$7, Final_COUNT(count$8) AS EXPR$8, Final_COUNT(count$9) AS EXPR$9, Final_COUNT(count$10) AS EXPR$10, Final_COUNT(count$11) AS EXPR$11, Final_COUNT(count$12) AS EXPR$12]), rowType=[RecordType(BIGINT EXP [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT count$0, BIGINT count$1, BIGINT count$2, BIGINT count$3, BIGINT count$4, BIGINT count$5, BIGINT count$6, BIGINT count$7, BIGINT count$8, BIGINT count$9, BIGINT count$10, BIGINT count$11, BIGINT count$12)]
-   +- LocalSortAggregate(select=[Partial_COUNT(byte) AS count$0, Partial_COUNT(short) AS count$1, Partial_COUNT(int) AS count$2, Partial_COUNT(long) AS count$3, Partial_COUNT(float) AS count$4, Partial_COUNT(double) AS count$5, Partial_COUNT(decimal3020) AS count$6, Partial_COUNT(decimal105) AS count$7, Partial_COUNT(boolean) AS count$8, Partial_COUNT(date) AS count$9, Partial_COUNT(time) AS count$10, Partial_COUNT(timestamp) AS count$11, Partial_COUNT(string) AS count$12]), rowType=[Rec [...]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregate[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), COUNT(c) FROM MyTable1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1, Final_COUNT(count$1) AS EXPR$2])
-+- Sort(orderBy=[a ASC])
-   +- Exchange(distribution=[hash[a]])
-      +- LocalSortAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0, Partial_COUNT(c) AS count$1])
-         +- Sort(orderBy=[a ASC])
-            +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCountStart[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT COUNT(*) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT()]), rowType=[RecordType(BIGINT EXPR$0)]
-+- LogicalProject($f0=[0]), rowType=[RecordType(INTEGER $f0)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_COUNT(count1$0) AS EXPR$0]), rowType=[RecordType(BIGINT EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT count1$0)]
-   +- LocalSortAggregate(select=[Partial_COUNT(*) AS count1$0]), rowType=[RecordType(BIGINT count1$0)]
-      +- Calc(select=[0 AS $f0]), rowType=[RecordType(INTEGER $f0)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCountStart[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT COUNT(*) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT()]), rowType=[RecordType(BIGINT EXPR$0)]
-+- LogicalProject($f0=[0]), rowType=[RecordType(INTEGER $f0)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], select=[COUNT(*) AS EXPR$0]), rowType=[RecordType(BIGINT EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(INTEGER $f0)]
-   +- Calc(select=[0 AS $f0]), rowType=[RecordType(INTEGER $f0)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testCountStart[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT COUNT(*) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[COUNT()]), rowType=[RecordType(BIGINT EXPR$0)]
-+- LogicalProject($f0=[0]), rowType=[RecordType(INTEGER $f0)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_COUNT(count1$0) AS EXPR$0]), rowType=[RecordType(BIGINT EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(BIGINT count1$0)]
-   +- LocalSortAggregate(select=[Partial_COUNT(*) AS count1$0]), rowType=[RecordType(BIGINT count1$0)]
-      +- Calc(select=[0 AS $f0]), rowType=[RecordType(INTEGER $f0)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregate[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), COUNT(c) FROM MyTable1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], groupBy=[a], select=[a, SUM(b) AS EXPR$1, COUNT(c) AS EXPR$2])
-+- Sort(orderBy=[a ASC])
-   +- Exchange(distribution=[hash[a]])
-      +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregate[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), COUNT(c) FROM MyTable1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1, Final_COUNT(count$1) AS EXPR$2])
-+- Sort(orderBy=[a ASC])
-   +- Exchange(distribution=[hash[a]])
-      +- LocalSortAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0, Partial_COUNT(c) AS count$1])
-         +- Sort(orderBy=[a ASC])
-            +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregateWithFilter[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), count(c) FROM MyTable1 WHERE a = 1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1, Final_COUNT(count$1) AS EXPR$2])
-+- Sort(orderBy=[a ASC])
-   +- Exchange(distribution=[hash[a]])
-      +- LocalSortAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0, Partial_COUNT(c) AS count$1])
-         +- Sort(orderBy=[a ASC])
-            +- Calc(select=[a, b, c], where=[=(a, 1)])
-               +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregateWithFilter[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), count(c) FROM MyTable1 WHERE a = 1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], groupBy=[a], select=[a, SUM(b) AS EXPR$1, COUNT(c) AS EXPR$2])
-+- Sort(orderBy=[a ASC])
-   +- Exchange(distribution=[hash[a]])
-      +- Calc(select=[a, b, c], where=[=(a, 1)])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testGroupAggregateWithFilter[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT a, SUM(b), count(c) FROM MyTable1 WHERE a = 1 GROUP BY a]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[SUM($1)], EXPR$2=[COUNT($2)])
-+- LogicalFilter(condition=[=($0, 1)])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], groupBy=[a], select=[a, Final_SUM(sum$0) AS EXPR$1, Final_COUNT(count$1) AS EXPR$2])
-+- Sort(orderBy=[a ASC])
-   +- Exchange(distribution=[hash[a]])
-      +- LocalSortAggregate(groupBy=[a], select=[a, Partial_SUM(b) AS sum$0, Partial_COUNT(c) AS count$1])
-         +- Sort(orderBy=[a ASC])
-            +- Calc(select=[a, b, c], where=[=(a, 1)])
-               +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMaxWithFixLengthType[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MAX(`byte`),
-       MAX(`short`),
-       MAX(`int`),
-       MAX(`long`),
-       MAX(`float`),
-       MAX(`double`),
-       MAX(`decimal3020`),
-       MAX(`decimal105`),
-       MAX(`boolean`),
-       MAX(`date`),
-       MAX(`time`),
-       MAX(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MAX($0)], EXPR$1=[MAX($1)], EXPR$2=[MAX($2)], EXPR$3=[MAX($3)], EXPR$4=[MAX($4)], EXPR$5=[MAX($5)], EXPR$6=[MAX($6)], EXPR$7=[MAX($7)], EXPR$8=[MAX($8)], EXPR$9=[MAX($9)], EXPR$10=[MAX($10)], EXPR$11=[MAX($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_MAX(max$0) AS EXPR$0, Final_MAX(max$1) AS EXPR$1, Final_MAX(max$2) AS EXPR$2, Final_MAX(max$3) AS EXPR$3, Final_MAX(max$4) AS EXPR$4, Final_MAX(max$5) AS EXPR$5, Final_MAX(max$6) AS EXPR$6, Final_MAX(max$7) AS EXPR$7, Final_MAX(max$8) AS EXPR$8, Final_MAX(max$9) AS EXPR$9, Final_MAX(max$10) AS EXPR$10, Final_MAX(max$11) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT max$0, SMALLINT max$1, INTEGER max$2, BIGINT max$3, FLOAT max$4, DOUBLE max$5, DECIMAL(30, 20) max$6, DECIMAL(10, 5) max$7, BOOLEAN max$8, INTEGER max$9, INTEGER max$10, BIGINT max$11)]
-   +- LocalSortAggregate(select=[Partial_MAX(byte) AS max$0, Partial_MAX(short) AS max$1, Partial_MAX(int) AS max$2, Partial_MAX(long) AS max$3, Partial_MAX(float) AS max$4, Partial_MAX(double) AS max$5, Partial_MAX(decimal3020) AS max$6, Partial_MAX(decimal105) AS max$7, Partial_MAX(boolean) AS max$8, Partial_MAX(date) AS max$9, Partial_MAX(time) AS max$10, Partial_MAX(timestamp) AS max$11]), rowType=[RecordType(TINYINT max$0, SMALLINT max$1, INTEGER max$2, BIGINT max$3, FLOAT max$4, DO [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMaxWithFixLengthType[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MAX(`byte`),
-       MAX(`short`),
-       MAX(`int`),
-       MAX(`long`),
-       MAX(`float`),
-       MAX(`double`),
-       MAX(`decimal3020`),
-       MAX(`decimal105`),
-       MAX(`boolean`),
-       MAX(`date`),
-       MAX(`time`),
-       MAX(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MAX($0)], EXPR$1=[MAX($1)], EXPR$2=[MAX($2)], EXPR$3=[MAX($3)], EXPR$4=[MAX($4)], EXPR$5=[MAX($5)], EXPR$6=[MAX($6)], EXPR$7=[MAX($7)], EXPR$8=[MAX($8)], EXPR$9=[MAX($9)], EXPR$10=[MAX($10)], EXPR$11=[MAX($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], select=[MAX(byte) AS EXPR$0, MAX(short) AS EXPR$1, MAX(int) AS EXPR$2, MAX(long) AS EXPR$3, MAX(float) AS EXPR$4, MAX(double) AS EXPR$5, MAX(decimal3020) AS EXPR$6, MAX(decimal105) AS EXPR$7, MAX(boolean) AS EXPR$8, MAX(date) AS EXPR$9, MAX(time) AS EXPR$10, MAX(timestamp) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$ [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMaxWithFixLengthType[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MAX(`byte`),
-       MAX(`short`),
-       MAX(`int`),
-       MAX(`long`),
-       MAX(`float`),
-       MAX(`double`),
-       MAX(`decimal3020`),
-       MAX(`decimal105`),
-       MAX(`boolean`),
-       MAX(`date`),
-       MAX(`time`),
-       MAX(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MAX($0)], EXPR$1=[MAX($1)], EXPR$2=[MAX($2)], EXPR$3=[MAX($3)], EXPR$4=[MAX($4)], EXPR$5=[MAX($5)], EXPR$6=[MAX($6)], EXPR$7=[MAX($7)], EXPR$8=[MAX($8)], EXPR$9=[MAX($9)], EXPR$10=[MAX($10)], EXPR$11=[MAX($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_MAX(max$0) AS EXPR$0, Final_MAX(max$1) AS EXPR$1, Final_MAX(max$2) AS EXPR$2, Final_MAX(max$3) AS EXPR$3, Final_MAX(max$4) AS EXPR$4, Final_MAX(max$5) AS EXPR$5, Final_MAX(max$6) AS EXPR$6, Final_MAX(max$7) AS EXPR$7, Final_MAX(max$8) AS EXPR$8, Final_MAX(max$9) AS EXPR$9, Final_MAX(max$10) AS EXPR$10, Final_MAX(max$11) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT max$0, SMALLINT max$1, INTEGER max$2, BIGINT max$3, FLOAT max$4, DOUBLE max$5, DECIMAL(30, 20) max$6, DECIMAL(10, 5) max$7, BOOLEAN max$8, INTEGER max$9, INTEGER max$10, BIGINT max$11)]
-   +- LocalSortAggregate(select=[Partial_MAX(byte) AS max$0, Partial_MAX(short) AS max$1, Partial_MAX(int) AS max$2, Partial_MAX(long) AS max$3, Partial_MAX(float) AS max$4, Partial_MAX(double) AS max$5, Partial_MAX(decimal3020) AS max$6, Partial_MAX(decimal105) AS max$7, Partial_MAX(boolean) AS max$8, Partial_MAX(date) AS max$9, Partial_MAX(time) AS max$10, Partial_MAX(timestamp) AS max$11]), rowType=[RecordType(TINYINT max$0, SMALLINT max$1, INTEGER max$2, BIGINT max$3, FLOAT max$4, DO [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMaxWithVariableLengthType[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT MAX(`string`) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MAX($0)]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- LogicalProject(string=[$7]), rowType=[RecordType(VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_MAX(max$0) AS EXPR$0]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(VARCHAR(65536) max$0)]
-   +- LocalSortAggregate(select=[Partial_MAX(string) AS max$0]), rowType=[RecordType(VARCHAR(65536) max$0)]
-      +- Calc(select=[string]), rowType=[RecordType(VARCHAR(65536) string)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMaxWithVariableLengthType[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT MAX(`string`) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MAX($0)]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- LogicalProject(string=[$7]), rowType=[RecordType(VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], select=[MAX(string) AS EXPR$0]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(VARCHAR(65536) string)]
-   +- Calc(select=[string]), rowType=[RecordType(VARCHAR(65536) string)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMaxWithVariableLengthType[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT MAX(`string`) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MAX($0)]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- LogicalProject(string=[$7]), rowType=[RecordType(VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_MAX(max$0) AS EXPR$0]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(VARCHAR(65536) max$0)]
-   +- LocalSortAggregate(select=[Partial_MAX(string) AS max$0]), rowType=[RecordType(VARCHAR(65536) max$0)]
-      +- Calc(select=[string]), rowType=[RecordType(VARCHAR(65536) string)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMinWithFixLengthType[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MIN(`byte`),
-       MIN(`short`),
-       MIN(`int`),
-       MIN(`long`),
-       MIN(`float`),
-       MIN(`double`),
-       MIN(`decimal3020`),
-       MIN(`decimal105`),
-       MIN(`boolean`),
-       MIN(`date`),
-       MIN(`time`),
-       MIN(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MIN($0)], EXPR$1=[MIN($1)], EXPR$2=[MIN($2)], EXPR$3=[MIN($3)], EXPR$4=[MIN($4)], EXPR$5=[MIN($5)], EXPR$6=[MIN($6)], EXPR$7=[MIN($7)], EXPR$8=[MIN($8)], EXPR$9=[MIN($9)], EXPR$10=[MIN($10)], EXPR$11=[MIN($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_MIN(min$0) AS EXPR$0, Final_MIN(min$1) AS EXPR$1, Final_MIN(min$2) AS EXPR$2, Final_MIN(min$3) AS EXPR$3, Final_MIN(min$4) AS EXPR$4, Final_MIN(min$5) AS EXPR$5, Final_MIN(min$6) AS EXPR$6, Final_MIN(min$7) AS EXPR$7, Final_MIN(min$8) AS EXPR$8, Final_MIN(min$9) AS EXPR$9, Final_MIN(min$10) AS EXPR$10, Final_MIN(min$11) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT min$0, SMALLINT min$1, INTEGER min$2, BIGINT min$3, FLOAT min$4, DOUBLE min$5, DECIMAL(30, 20) min$6, DECIMAL(10, 5) min$7, BOOLEAN min$8, INTEGER min$9, INTEGER min$10, BIGINT min$11)]
-   +- LocalSortAggregate(select=[Partial_MIN(byte) AS min$0, Partial_MIN(short) AS min$1, Partial_MIN(int) AS min$2, Partial_MIN(long) AS min$3, Partial_MIN(float) AS min$4, Partial_MIN(double) AS min$5, Partial_MIN(decimal3020) AS min$6, Partial_MIN(decimal105) AS min$7, Partial_MIN(boolean) AS min$8, Partial_MIN(date) AS min$9, Partial_MIN(time) AS min$10, Partial_MIN(timestamp) AS min$11]), rowType=[RecordType(TINYINT min$0, SMALLINT min$1, INTEGER min$2, BIGINT min$3, FLOAT min$4, DO [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMinWithFixLengthType[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MIN(`byte`),
-       MIN(`short`),
-       MIN(`int`),
-       MIN(`long`),
-       MIN(`float`),
-       MIN(`double`),
-       MIN(`decimal3020`),
-       MIN(`decimal105`),
-       MIN(`boolean`),
-       MIN(`date`),
-       MIN(`time`),
-       MIN(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MIN($0)], EXPR$1=[MIN($1)], EXPR$2=[MIN($2)], EXPR$3=[MIN($3)], EXPR$4=[MIN($4)], EXPR$5=[MIN($5)], EXPR$6=[MIN($6)], EXPR$7=[MIN($7)], EXPR$8=[MIN($8)], EXPR$9=[MIN($9)], EXPR$10=[MIN($10)], EXPR$11=[MIN($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], select=[MIN(byte) AS EXPR$0, MIN(short) AS EXPR$1, MIN(int) AS EXPR$2, MIN(long) AS EXPR$3, MIN(float) AS EXPR$4, MIN(double) AS EXPR$5, MIN(decimal3020) AS EXPR$6, MIN(decimal105) AS EXPR$7, MIN(boolean) AS EXPR$8, MIN(date) AS EXPR$9, MIN(time) AS EXPR$10, MIN(timestamp) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$ [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMinWithFixLengthType[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT MIN(`byte`),
-       MIN(`short`),
-       MIN(`int`),
-       MIN(`long`),
-       MIN(`float`),
-       MIN(`double`),
-       MIN(`decimal3020`),
-       MIN(`decimal105`),
-       MIN(`boolean`),
-       MIN(`date`),
-       MIN(`time`),
-       MIN(`timestamp`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MIN($0)], EXPR$1=[MIN($1)], EXPR$2=[MIN($2)], EXPR$3=[MIN($3)], EXPR$4=[MIN($4)], EXPR$5=[MIN($5)], EXPR$6=[MIN($6)], EXPR$7=[MIN($7)], EXPR$8=[MIN($8)], EXPR$9=[MIN($9)], EXPR$10=[MIN($10)], EXPR$11=[MIN($11)]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(30, 20) EXPR$6, DECIMAL(10, 5) EXPR$7, BOOLEAN EXPR$8, DATE EXPR$9, TIME(0) EXPR$10, TIMESTAMP(3) EXPR$11)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12], boolean=[$6], date=[$8], time=[$9], timestamp=[$10]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_MIN(min$0) AS EXPR$0, Final_MIN(min$1) AS EXPR$1, Final_MIN(min$2) AS EXPR$2, Final_MIN(min$3) AS EXPR$3, Final_MIN(min$4) AS EXPR$4, Final_MIN(min$5) AS EXPR$5, Final_MIN(min$6) AS EXPR$6, Final_MIN(min$7) AS EXPR$7, Final_MIN(min$8) AS EXPR$8, Final_MIN(min$9) AS EXPR$9, Final_MIN(min$10) AS EXPR$10, Final_MIN(min$11) AS EXPR$11]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, [...]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT min$0, SMALLINT min$1, INTEGER min$2, BIGINT min$3, FLOAT min$4, DOUBLE min$5, DECIMAL(30, 20) min$6, DECIMAL(10, 5) min$7, BOOLEAN min$8, INTEGER min$9, INTEGER min$10, BIGINT min$11)]
-   +- LocalSortAggregate(select=[Partial_MIN(byte) AS min$0, Partial_MIN(short) AS min$1, Partial_MIN(int) AS min$2, Partial_MIN(long) AS min$3, Partial_MIN(float) AS min$4, Partial_MIN(double) AS min$5, Partial_MIN(decimal3020) AS min$6, Partial_MIN(decimal105) AS min$7, Partial_MIN(boolean) AS min$8, Partial_MIN(date) AS min$9, Partial_MIN(time) AS min$10, Partial_MIN(timestamp) AS min$11]), rowType=[RecordType(TINYINT min$0, SMALLINT min$1, INTEGER min$2, BIGINT min$3, FLOAT min$4, DO [...]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105, boolean, date, time, timestamp]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105, BOOLEAN boolean, DATE date, TIME(0) time, TIMESTAMP(3) timestamp)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMinWithVariableLengthType[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT MIN(`string`) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MIN($0)]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- LogicalProject(string=[$7]), rowType=[RecordType(VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_MIN(min$0) AS EXPR$0]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(VARCHAR(65536) min$0)]
-   +- LocalSortAggregate(select=[Partial_MIN(string) AS min$0]), rowType=[RecordType(VARCHAR(65536) min$0)]
-      +- Calc(select=[string]), rowType=[RecordType(VARCHAR(65536) string)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMinWithVariableLengthType[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT MIN(`string`) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MIN($0)]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- LogicalProject(string=[$7]), rowType=[RecordType(VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], select=[MIN(string) AS EXPR$0]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(VARCHAR(65536) string)]
-   +- Calc(select=[string]), rowType=[RecordType(VARCHAR(65536) string)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testMinWithVariableLengthType[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT MIN(`string`) FROM MyTable]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[MIN($0)]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- LogicalProject(string=[$7]), rowType=[RecordType(VARCHAR(65536) string)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_MIN(min$0) AS EXPR$0]), rowType=[RecordType(VARCHAR(65536) EXPR$0)]
-+- Exchange(distribution=[single]), rowType=[RecordType(VARCHAR(65536) min$0)]
-   +- LocalSortAggregate(select=[Partial_MIN(string) AS min$0]), rowType=[RecordType(VARCHAR(65536) min$0)]
-      +- Calc(select=[string]), rowType=[RecordType(VARCHAR(65536) string)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testSum[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT SUM(`byte`),
-       SUM(`short`),
-       SUM(`int`),
-       SUM(`long`),
-       SUM(`float`),
-       SUM(`double`),
-       SUM(`decimal3020`),
-       SUM(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[SUM($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(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_SUM(sum$0) AS EXPR$0, Final_SUM(sum$1) AS EXPR$1, Final_SUM(sum$2) AS EXPR$2, Final_SUM(sum$3) AS EXPR$3, Final_SUM(sum$4) AS EXPR$4, Final_SUM(sum$5) AS EXPR$5, Final_SUM(sum$6) AS EXPR$6, Final_SUM(sum$7) AS EXPR$7]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT sum$0, SMALLINT sum$1, INTEGER sum$2, BIGINT sum$3, FLOAT sum$4, DOUBLE sum$5, DECIMAL(38, 20) sum$6, DECIMAL(38, 5) sum$7)]
-   +- LocalSortAggregate(select=[Partial_SUM(byte) AS sum$0, Partial_SUM(short) AS sum$1, Partial_SUM(int) AS sum$2, Partial_SUM(long) AS sum$3, Partial_SUM(float) AS sum$4, Partial_SUM(double) AS sum$5, Partial_SUM(decimal3020) AS sum$6, Partial_SUM(decimal105) AS sum$7]), rowType=[RecordType(TINYINT sum$0, SMALLINT sum$1, INTEGER sum$2, BIGINT sum$3, FLOAT sum$4, DOUBLE sum$5, DECIMAL(38, 20) sum$6, DECIMAL(38, 5) sum$7)]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testPojoAccumulator[aggStrategy=NONE]">
-    <Resource name="sql">
-      <![CDATA[SELECT b, var_sum(a) FROM MyTable1 GROUP BY b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[var_sum($1)])
-+- LogicalProject(b=[$1], a=[$0])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], groupBy=[b], select=[b, var_sum(a) AS EXPR$1])
-+- Sort(orderBy=[b ASC])
-   +- Exchange(distribution=[hash[b]])
-      +- Calc(select=[b, a])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testPojoAccumulator[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT b, var_sum(a) FROM MyTable1 GROUP BY b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[var_sum($1)])
-+- LogicalProject(b=[$1], a=[$0])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], groupBy=[b], select=[b, var_sum(a) AS EXPR$1])
-+- Sort(orderBy=[b ASC])
-   +- Exchange(distribution=[hash[b]])
-      +- Calc(select=[b, a])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testSum[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT SUM(`byte`),
-       SUM(`short`),
-       SUM(`int`),
-       SUM(`long`),
-       SUM(`float`),
-       SUM(`double`),
-       SUM(`decimal3020`),
-       SUM(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[SUM($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(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], select=[SUM(byte) AS EXPR$0, SUM(short) AS EXPR$1, SUM(int) AS EXPR$2, SUM(long) AS EXPR$3, SUM(float) AS EXPR$4, SUM(double) AS EXPR$5, SUM(decimal3020) AS EXPR$6, SUM(decimal105) AS EXPR$7]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-      +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30 [...]
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testPojoAccumulator[aggStrategy=ONE_PHASE]">
-    <Resource name="sql">
-      <![CDATA[SELECT b, var_sum(a) FROM MyTable1 GROUP BY b]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{0}], EXPR$1=[var_sum($1)])
-+- LogicalProject(b=[$1], a=[$0])
-   +- LogicalTableScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[false], groupBy=[b], select=[b, var_sum(a) AS EXPR$1])
-+- Sort(orderBy=[b ASC])
-   +- Exchange(distribution=[hash[b]])
-      +- Calc(select=[b, a])
-         +- TableSourceScan(table=[[MyTable1, source: [TestTableSource(a, b, c)]]], fields=[a, b, c])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testSum[aggStrategy=TWO_PHASE]">
-    <Resource name="sql">
-      <![CDATA[
-SELECT SUM(`byte`),
-       SUM(`short`),
-       SUM(`int`),
-       SUM(`long`),
-       SUM(`float`),
-       SUM(`double`),
-       SUM(`decimal3020`),
-       SUM(`decimal105`)
-FROM MyTable
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalAggregate(group=[{}], EXPR$0=[SUM($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(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- LogicalProject(byte=[$0], short=[$1], int=[$2], long=[$3], float=[$4], double=[$5], decimal3020=[$11], decimal105=[$12]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-   +- LogicalTableScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-SortAggregate(isMerge=[true], select=[Final_SUM(sum$0) AS EXPR$0, Final_SUM(sum$1) AS EXPR$1, Final_SUM(sum$2) AS EXPR$2, Final_SUM(sum$3) AS EXPR$3, Final_SUM(sum$4) AS EXPR$4, Final_SUM(sum$5) AS EXPR$5, Final_SUM(sum$6) AS EXPR$6, Final_SUM(sum$7) AS EXPR$7]), rowType=[RecordType(TINYINT EXPR$0, SMALLINT EXPR$1, INTEGER EXPR$2, BIGINT EXPR$3, FLOAT EXPR$4, DOUBLE EXPR$5, DECIMAL(38, 20) EXPR$6, DECIMAL(38, 5) EXPR$7)]
-+- Exchange(distribution=[single]), rowType=[RecordType(TINYINT sum$0, SMALLINT sum$1, INTEGER sum$2, BIGINT sum$3, FLOAT sum$4, DOUBLE sum$5, DECIMAL(38, 20) sum$6, DECIMAL(38, 5) sum$7)]
-   +- LocalSortAggregate(select=[Partial_SUM(byte) AS sum$0, Partial_SUM(short) AS sum$1, Partial_SUM(int) AS sum$2, Partial_SUM(long) AS sum$3, Partial_SUM(float) AS sum$4, Partial_SUM(double) AS sum$5, Partial_SUM(decimal3020) AS sum$6, Partial_SUM(decimal105) AS sum$7]), rowType=[RecordType(TINYINT sum$0, SMALLINT sum$1, INTEGER sum$2, BIGINT sum$3, FLOAT sum$4, DOUBLE sum$5, DECIMAL(38, 20) sum$6, DECIMAL(38, 5) sum$7)]
-      +- Calc(select=[byte, short, int, long, float, double, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, DECIMAL(30, 20) decimal3020, DECIMAL(10, 5) decimal105)]
-         +- TableSourceScan(table=[[MyTable, source: [TestTableSource(byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105)]]], fields=[byte, short, int, long, float, double, boolean, string, date, time, timestamp, decimal3020, decimal105]), rowType=[RecordType(TINYINT byte, SMALLINT short, INTEGER int, BIGINT long, FLOAT float, DOUBLE double, BOOLEAN boolean, VARCHAR(65536) string, DATE date, TIME(0) time, TIMESTAMP(3) timestamp, DECIMAL [...]
-]]>
-    </Resource>
-  </TestCase>
-</Root>
diff --git a/flink-table/flink-table-planner-blink/src/test/resources/org/apache/flink/table/plan/batch/sql/join/SingleRowJoinTest.xml b/flink-table/flink-table-planner-blink/src/test/resources/org/apache/flink/table/plan/batch/sql/join/SingleRowJoinTest.xml
deleted file mode 100644
index f4f7e7e..0000000
--- a/flink-table/flink-table-planner-blink/src/test/resources/org/apache/flink/table/plan/batch/sql/join/SingleRowJoinTest.xml
+++ /dev/null
@@ -1,250 +0,0 @@
-<?xml version="1.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.
--->
-<Root>
-  <TestCase name="testSingleRowNotEquiJoin">
-    <Resource name="sql">
-      <![CDATA[SELECT a1, a2 FROM A, (SELECT COUNT(a1) AS cnt FROM A) WHERE a1 < cnt]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalProject(a1=[$0], a2=[$1])
-+- LogicalFilter(condition=[<($0, $2)])
-   +- LogicalJoin(condition=[true], joinType=[inner])
-      :- LogicalTableScan(table=[[A, source: [TestTableSource(a1, a2)]]])
-      +- LogicalAggregate(group=[{}], cnt=[COUNT($0)])
-         +- LogicalProject(a1=[$0])
-            +- LogicalTableScan(table=[[A, source: [TestTableSource(a1, a2)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-Calc(select=[a1, a2])
-+- NestedLoopJoin(joinType=[InnerJoin], where=[<(a1, cnt)], select=[a1, a2, cnt], build=[right], singleRowJoin=[true])
-   :- TableSourceScan(table=[[A, source: [TestTableSource(a1, a2)]]], fields=[a1, a2])
-   +- Exchange(distribution=[broadcast])
-      +- HashAggregate(isMerge=[true], select=[Final_COUNT(count$0) AS cnt])
-         +- Exchange(distribution=[single])
-            +- LocalHashAggregate(select=[Partial_COUNT(a1) AS count$0])
-               +- Calc(select=[a1])
-                  +- TableSourceScan(table=[[A, source: [TestTableSource(a1, a2)]]], fields=[a1, a2])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testLeftSingleRightJoinEqualPredicate">
-    <Resource name="sql">
-      <![CDATA[SELECT a1 FROM (SELECT COUNT(*) AS cnt FROM B) RIGHT JOIN A ON cnt = a2]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalProject(a1=[$1])
-+- LogicalJoin(condition=[=($0, $2)], joinType=[right])
-   :- LogicalAggregate(group=[{}], cnt=[COUNT()])
-   :  +- LogicalProject($f0=[0])
-   :     +- LogicalTableScan(table=[[B, source: [TestTableSource(b1, b2)]]])
-   +- LogicalTableScan(table=[[A, source: [TestTableSource(a1, a2)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-Calc(select=[a1])
-+- HashJoin(joinType=[RightOuterJoin], where=[=(cnt, a2)], select=[cnt, a1, a2], build=[left])
-   :- Exchange(distribution=[hash[cnt]])
-   :  +- HashAggregate(isMerge=[true], select=[Final_COUNT(count1$0) AS cnt])
-   :     +- Exchange(distribution=[single])
-   :        +- LocalHashAggregate(select=[Partial_COUNT(*) AS count1$0])
-   :           +- Calc(select=[0 AS $f0])
-   :              +- TableSourceScan(table=[[B, source: [TestTableSource(b1, b2)]]], fields=[b1, b2])
-   +- Exchange(distribution=[hash[a2]])
-      +- TableSourceScan(table=[[A, source: [TestTableSource(a1, a2)]]], fields=[a1, a2])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testLeftSingleRightJoinNotEqualPredicate">
-    <Resource name="sql">
-      <![CDATA[SELECT a1 FROM (SELECT COUNT(*) AS cnt FROM B) RIGHT JOIN A ON cnt < a2]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalProject(a1=[$1])
-+- LogicalJoin(condition=[<($0, $2)], joinType=[right])
-   :- LogicalAggregate(group=[{}], cnt=[COUNT()])
-   :  +- LogicalProject($f0=[0])
-   :     +- LogicalTableScan(table=[[B, source: [TestTableSource(b1, b2)]]])
-   +- LogicalTableScan(table=[[A, source: [TestTableSource(a1, a2)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-Calc(select=[a1])
-+- NestedLoopJoin(joinType=[RightOuterJoin], where=[<(cnt, a2)], select=[cnt, a1, a2], build=[left], singleRowJoin=[true])
-   :- Exchange(distribution=[broadcast])
-   :  +- HashAggregate(isMerge=[true], select=[Final_COUNT(count1$0) AS cnt])
-   :     +- Exchange(distribution=[single])
-   :        +- LocalHashAggregate(select=[Partial_COUNT(*) AS count1$0])
-   :           +- Calc(select=[0 AS $f0])
-   :              +- TableSourceScan(table=[[B, source: [TestTableSource(b1, b2)]]], fields=[b1, b2])
-   +- TableSourceScan(table=[[A, source: [TestTableSource(a1, a2)]]], fields=[a1, a2])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testRightSingleLeftJoinNotEqualPredicate">
-    <Resource name="sql">
-      <![CDATA[SELECT a2 FROM A LEFT JOIN (SELECT COUNT(*) AS cnt FROM B) AS x ON a1 > cnt]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalProject(a2=[$1])
-+- LogicalJoin(condition=[>($0, $2)], joinType=[left])
-   :- LogicalTableScan(table=[[A, source: [TestTableSource(a1, a2)]]])
-   +- LogicalAggregate(group=[{}], cnt=[COUNT()])
-      +- LogicalProject($f0=[0])
-         +- LogicalTableScan(table=[[B, source: [TestTableSource(b1, b2)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-Calc(select=[a2])
-+- NestedLoopJoin(joinType=[LeftOuterJoin], where=[>(a1, cnt)], select=[a1, a2, cnt], build=[right], singleRowJoin=[true])
-   :- TableSourceScan(table=[[A, source: [TestTableSource(a1, a2)]]], fields=[a1, a2])
-   +- Exchange(distribution=[broadcast])
-      +- HashAggregate(isMerge=[true], select=[Final_COUNT(count1$0) AS cnt])
-         +- Exchange(distribution=[single])
-            +- LocalHashAggregate(select=[Partial_COUNT(*) AS count1$0])
-               +- Calc(select=[0 AS $f0])
-                  +- TableSourceScan(table=[[B, source: [TestTableSource(b1, b2)]]], fields=[b1, b2])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testSingleRowCrossJoin">
-    <Resource name="sql">
-      <![CDATA[SELECT a1, a_sum FROM A, (SELECT SUM(a1) + SUM(a2) AS a_sum FROM A)]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalProject(a1=[$0], a_sum=[$2])
-+- LogicalJoin(condition=[true], joinType=[inner])
-   :- LogicalTableScan(table=[[A, source: [TestTableSource(a1, a2)]]])
-   +- LogicalProject(a_sum=[+($0, $1)])
-      +- LogicalAggregate(group=[{}], agg#0=[SUM($0)], agg#1=[SUM($1)])
-         +- LogicalTableScan(table=[[A, source: [TestTableSource(a1, a2)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-NestedLoopJoin(joinType=[InnerJoin], where=[true], select=[a1, a_sum], build=[right], singleRowJoin=[true])
-:- Calc(select=[a1])
-:  +- TableSourceScan(table=[[A, source: [TestTableSource(a1, a2)]]], fields=[a1, a2])
-+- Exchange(distribution=[broadcast])
-   +- Calc(select=[+($f0, $f1) AS a_sum])
-      +- HashAggregate(isMerge=[true], select=[Final_SUM(sum$0) AS $f0, Final_SUM(sum$1) AS $f1])
-         +- Exchange(distribution=[single])
-            +- LocalHashAggregate(select=[Partial_SUM(a1) AS sum$0, Partial_SUM(a2) AS sum$1])
-               +- TableSourceScan(table=[[A, source: [TestTableSource(a1, a2)]]], fields=[a1, a2])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testRightSingleLeftJoinEqualPredicate">
-    <Resource name="sql">
-      <![CDATA[SELECT a2 FROM A LEFT JOIN (SELECT COUNT(*) AS cnt FROM B) AS x  ON a1 = cnt]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalProject(a2=[$1])
-+- LogicalJoin(condition=[=($0, $2)], joinType=[left])
-   :- LogicalTableScan(table=[[A, source: [TestTableSource(a1, a2)]]])
-   +- LogicalAggregate(group=[{}], cnt=[COUNT()])
-      +- LogicalProject($f0=[0])
-         +- LogicalTableScan(table=[[B, source: [TestTableSource(b1, b2)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-Calc(select=[a2])
-+- HashJoin(joinType=[LeftOuterJoin], where=[=(a1, cnt)], select=[a1, a2, cnt], build=[right])
-   :- Exchange(distribution=[hash[a1]])
-   :  +- TableSourceScan(table=[[A, source: [TestTableSource(a1, a2)]]], fields=[a1, a2])
-   +- Exchange(distribution=[hash[cnt]])
-      +- HashAggregate(isMerge=[true], select=[Final_COUNT(count1$0) AS cnt])
-         +- Exchange(distribution=[single])
-            +- LocalHashAggregate(select=[Partial_COUNT(*) AS count1$0])
-               +- Calc(select=[0 AS $f0])
-                  +- TableSourceScan(table=[[B, source: [TestTableSource(b1, b2)]]], fields=[b1, b2])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testSingleRowEquiJoin">
-    <Resource name="sql">
-      <![CDATA[SELECT a1, a2 FROM A, (SELECT COUNT(a1) AS cnt FROM A) WHERE a1 = cnt]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalProject(a1=[$0], a2=[$1])
-+- LogicalFilter(condition=[=(CAST($0):BIGINT, $2)])
-   +- LogicalJoin(condition=[true], joinType=[inner])
-      :- LogicalTableScan(table=[[A, source: [TestTableSource(a1, a2)]]])
-      +- LogicalAggregate(group=[{}], cnt=[COUNT($0)])
-         +- LogicalProject(a1=[$0])
-            +- LogicalTableScan(table=[[A, source: [TestTableSource(a1, a2)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-Calc(select=[a1, a2])
-+- NestedLoopJoin(joinType=[InnerJoin], where=[=(CAST(a1), cnt)], select=[a1, a2, cnt], build=[right], singleRowJoin=[true])
-   :- TableSourceScan(table=[[A, source: [TestTableSource(a1, a2)]]], fields=[a1, a2])
-   +- Exchange(distribution=[broadcast])
-      +- HashAggregate(isMerge=[true], select=[Final_COUNT(count$0) AS cnt])
-         +- Exchange(distribution=[single])
-            +- LocalHashAggregate(select=[Partial_COUNT(a1) AS count$0])
-               +- Calc(select=[a1])
-                  +- TableSourceScan(table=[[A, source: [TestTableSource(a1, a2)]]], fields=[a1, a2])
-]]>
-    </Resource>
-  </TestCase>
-  <TestCase name="testSingleRowJoinWithComplexPredicate">
-    <Resource name="sql">
-      <![CDATA[
-SELECT a1, a2, b1, b2 FROM A,
-  (SELECT min(b1) AS b1, max(b2) AS b2 FROM B)
-WHERE a1 < b1 AND a2 = b2
-      ]]>
-    </Resource>
-    <Resource name="planBefore">
-      <![CDATA[
-LogicalProject(a1=[$0], a2=[$1], b1=[$2], b2=[$3])
-+- LogicalFilter(condition=[AND(<($0, $2), =($1, $3))])
-   +- LogicalJoin(condition=[true], joinType=[inner])
-      :- LogicalTableScan(table=[[A, source: [TestTableSource(a1, a2)]]])
-      +- LogicalAggregate(group=[{}], b1=[MIN($0)], b2=[MAX($1)])
-         +- LogicalTableScan(table=[[B, source: [TestTableSource(b1, b2)]]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-HashJoin(joinType=[InnerJoin], where=[AND(<(a1, b1), =(a2, b2))], select=[a1, a2, b1, b2], build=[right])
-:- Exchange(distribution=[hash[a2]])
-:  +- TableSourceScan(table=[[A, source: [TestTableSource(a1, a2)]]], fields=[a1, a2])
-+- Exchange(distribution=[hash[b2]])
-   +- HashAggregate(isMerge=[true], select=[Final_MIN(min$0) AS b1, Final_MAX(max$1) AS b2])
-      +- Exchange(distribution=[single])
-         +- LocalHashAggregate(select=[Partial_MIN(b1) AS min$0, Partial_MAX(b2) AS max$1])
-            +- TableSourceScan(table=[[B, source: [TestTableSource(b1, b2)]]], fields=[b1, b2])
-]]>
-    </Resource>
-  </TestCase>
-</Root>
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/AggregateTestBase.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/AggregateTestBase.scala
deleted file mode 100644
index 839dea2..0000000
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/AggregateTestBase.scala
+++ /dev/null
@@ -1,202 +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.plan.batch.sql
-
-import org.apache.flink.api.common.typeinfo.TypeInformation
-import org.apache.flink.api.scala._
-import org.apache.flink.table.api.{TableException, Types}
-import org.apache.flink.table.plan.util.JavaUserDefinedAggFunctions.{VarSum1AggFunction, VarSum2AggFunction}
-import org.apache.flink.table.typeutils.DecimalTypeInfo
-import org.apache.flink.table.util.{BatchTableTestUtil, TableTestBase}
-
-import org.junit.Test
-
-abstract class AggregateTestBase extends TableTestBase {
-
-  protected val util: BatchTableTestUtil = batchTestUtil()
-  util.addTableSource("MyTable",
-    Array[TypeInformation[_]](
-      Types.BYTE, Types.SHORT, Types.INT, Types.LONG, Types.FLOAT, Types.DOUBLE, Types.BOOLEAN,
-      Types.STRING, Types.SQL_DATE, Types.SQL_TIME, Types.SQL_TIMESTAMP,
-      DecimalTypeInfo.of(30, 20), DecimalTypeInfo.of(10, 5)),
-    Array("byte", "short", "int", "long", "float", "double", "boolean",
-      "string", "date", "time", "timestamp", "decimal3020", "decimal105"))
-  util.addTableSource[(Int, Long, String)]("MyTable1", 'a, 'b, 'c)
-
-  @Test
-  def testAvg(): Unit = {
-    util.verifyPlanWithType(
-      """
-        |SELECT AVG(`byte`),
-        |       AVG(`short`),
-        |       AVG(`int`),
-        |       AVG(`long`),
-        |       AVG(`float`),
-        |       AVG(`double`),
-        |       AVG(`decimal3020`),
-        |       AVG(`decimal105`)
-        |FROM MyTable
-      """.stripMargin)
-  }
-
-  @Test
-  def testSum(): Unit = {
-    util.verifyPlanWithType(
-      """
-        |SELECT SUM(`byte`),
-        |       SUM(`short`),
-        |       SUM(`int`),
-        |       SUM(`long`),
-        |       SUM(`float`),
-        |       SUM(`double`),
-        |       SUM(`decimal3020`),
-        |       SUM(`decimal105`)
-        |FROM MyTable
-      """.stripMargin)
-  }
-
-  @Test
-  def testCount(): Unit = {
-    util.verifyPlanWithType(
-      """
-        |SELECT COUNT(`byte`),
-        |       COUNT(`short`),
-        |       COUNT(`int`),
-        |       COUNT(`long`),
-        |       COUNT(`float`),
-        |       COUNT(`double`),
-        |       COUNT(`decimal3020`),
-        |       COUNT(`decimal105`),
-        |       COUNT(`boolean`),
-        |       COUNT(`date`),
-        |       COUNT(`time`),
-        |       COUNT(`timestamp`),
-        |       COUNT(`string`)
-        |FROM MyTable
-      """.stripMargin)
-  }
-
-  @Test
-  def testCountStart(): Unit = {
-    util.verifyPlanWithType("SELECT COUNT(*) FROM MyTable")
-  }
-
-
-  @Test
-  def testCannotCountOnMultiFields(): Unit = {
-    val sql = "SELECT b, COUNT(a, c) FROM MyTable GROUP BY b"
-    thrown.expect(classOf[TableException])
-    thrown.expectMessage("We now only support the count of one field")
-    util.verifyPlan(sql)
-  }
-
-  @Test
-  def testMinWithFixLengthType(): Unit = {
-    util.verifyPlanWithType(
-      """
-        |SELECT MIN(`byte`),
-        |       MIN(`short`),
-        |       MIN(`int`),
-        |       MIN(`long`),
-        |       MIN(`float`),
-        |       MIN(`double`),
-        |       MIN(`decimal3020`),
-        |       MIN(`decimal105`),
-        |       MIN(`boolean`),
-        |       MIN(`date`),
-        |       MIN(`time`),
-        |       MIN(`timestamp`)
-        |FROM MyTable
-      """.stripMargin)
-  }
-
-  @Test
-  def testMinWithVariableLengthType(): Unit = {
-    util.verifyPlanWithType("SELECT MIN(`string`) FROM MyTable")
-  }
-
-  @Test
-  def testMaxWithFixLengthType(): Unit = {
-    util.verifyPlanWithType(
-      """
-        |SELECT MAX(`byte`),
-        |       MAX(`short`),
-        |       MAX(`int`),
-        |       MAX(`long`),
-        |       MAX(`float`),
-        |       MAX(`double`),
-        |       MAX(`decimal3020`),
-        |       MAX(`decimal105`),
-        |       MAX(`boolean`),
-        |       MAX(`date`),
-        |       MAX(`time`),
-        |       MAX(`timestamp`)
-        |FROM MyTable
-      """.stripMargin)
-  }
-
-  @Test
-  def testMaxWithVariableLengthType(): Unit = {
-    util.verifyPlanWithType("SELECT MAX(`string`) FROM MyTable")
-  }
-
-  @Test
-  def testAggregateWithoutFunction(): Unit = {
-    util.verifyPlan("SELECT a, b FROM MyTable1 GROUP BY a, b")
-  }
-
-  @Test
-  def testAggregateWithoutGroupBy(): Unit = {
-    util.verifyPlan("SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1")
-  }
-
-  @Test
-  def testAggregateWithFilter(): Unit = {
-    util.verifyPlan("SELECT AVG(a), SUM(b), COUNT(c) FROM MyTable1 WHERE a = 1")
-  }
-
-  @Test
-  def testAggregateWithFilterOnNestedFields(): Unit = {
-    util.addTableSource[(Int, Long, (Int, Long))]("MyTable2", 'a, 'b, 'c)
-    util.verifyPlan("SELECT AVG(a), SUM(b), COUNT(c), SUM(c._1) FROM MyTable2 WHERE a = 1")
-  }
-
-  @Test
-  def testGroupAggregate(): Unit = {
-    util.verifyPlan("SELECT a, SUM(b), COUNT(c) FROM MyTable1 GROUP BY a")
-  }
-
-  @Test
-  def testGroupAggregateWithFilter(): Unit = {
-    util.verifyPlan("SELECT a, SUM(b), count(c) FROM MyTable1 WHERE a = 1 GROUP BY a")
-  }
-
-  @Test
-  def testAggNotSupportMerge(): Unit = {
-    util.tableEnv.registerFunction("var_sum", new VarSum2AggFunction)
-    util.verifyPlan("SELECT b, var_sum(a) FROM MyTable1 GROUP BY b")
-  }
-
-  @Test
-  def testPojoAccumulator(): Unit = {
-    util.tableEnv.registerFunction("var_sum", new VarSum1AggFunction)
-    util.verifyPlan("SELECT b, var_sum(a) FROM MyTable1 GROUP BY b")
-  }
-
-  // TODO supports group sets
-}
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/HashAggregateTest.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/HashAggregateTest.scala
deleted file mode 100644
index 47eeb52..0000000
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/HashAggregateTest.scala
+++ /dev/null
@@ -1,72 +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.plan.batch.sql
-
-import org.apache.flink.table.api.AggPhaseEnforcer.AggPhaseEnforcer
-import org.apache.flink.table.api.{AggPhaseEnforcer, OperatorType, PlannerConfigOptions, TableConfigOptions, TableException, ValidationException}
-
-import org.junit.Before
-import org.junit.runner.RunWith
-import org.junit.runners.Parameterized
-
-import java.util
-
-import scala.collection.JavaConversions._
-
-@RunWith(classOf[Parameterized])
-class HashAggregateTest(aggStrategy: AggPhaseEnforcer) extends AggregateTestBase {
-
-  @Before
-  def before(): Unit = {
-    // disable sort agg
-    util.tableEnv.getConfig.getConf.setString(
-      TableConfigOptions.SQL_EXEC_DISABLED_OPERATORS, OperatorType.SortAgg.toString)
-    util.tableEnv.getConfig.getConf.setString(
-      PlannerConfigOptions.SQL_OPTIMIZER_AGG_PHASE_ENFORCER, aggStrategy.toString)
-  }
-
-  override def testMinWithVariableLengthType(): Unit = {
-    thrown.expect(classOf[TableException])
-    thrown.expectMessage("Cannot generate a valid execution plan for the given query")
-    super.testMinWithVariableLengthType()
-  }
-
-  override def testMaxWithVariableLengthType(): Unit = {
-    thrown.expect(classOf[TableException])
-    thrown.expectMessage("Cannot generate a valid execution plan for the given query")
-    super.testMaxWithVariableLengthType()
-  }
-
-  override def testPojoAccumulator(): Unit = {
-    thrown.expect(classOf[TableException])
-    thrown.expectMessage("Cannot generate a valid execution plan for the given query")
-    super.testPojoAccumulator()
-  }
-}
-
-object HashAggregateTest {
-
-  @Parameterized.Parameters(name = "aggStrategy={0}")
-  def parameters(): util.Collection[AggPhaseEnforcer] = {
-    Seq[AggPhaseEnforcer](
-      AggPhaseEnforcer.NONE,
-      AggPhaseEnforcer.ONE_PHASE,
-      AggPhaseEnforcer.TWO_PHASE
-    )
-  }
-}
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/SortAggregateTest.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/SortAggregateTest.scala
deleted file mode 100644
index d4b808c..0000000
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/SortAggregateTest.scala
+++ /dev/null
@@ -1,54 +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.plan.batch.sql
-
-import org.apache.flink.table.api.AggPhaseEnforcer.AggPhaseEnforcer
-import org.apache.flink.table.api.{AggPhaseEnforcer, OperatorType, PlannerConfigOptions, TableConfigOptions}
-
-import org.junit.Before
-import org.junit.runner.RunWith
-import org.junit.runners.Parameterized
-
-import java.util
-
-import scala.collection.JavaConversions._
-
-@RunWith(classOf[Parameterized])
-class SortAggregateTest(aggStrategy: AggPhaseEnforcer) extends AggregateTestBase {
-
-  @Before
-  def before(): Unit = {
-    // disable hash agg
-    util.tableEnv.getConfig.getConf.setString(
-      TableConfigOptions.SQL_EXEC_DISABLED_OPERATORS, OperatorType.HashAgg.toString)
-    util.tableEnv.getConfig.getConf.setString(
-      PlannerConfigOptions.SQL_OPTIMIZER_AGG_PHASE_ENFORCER, aggStrategy.toString)
-  }
-}
-
-object SortAggregateTest {
-
-  @Parameterized.Parameters(name = "aggStrategy={0}")
-  def parameters(): util.Collection[AggPhaseEnforcer] = {
-    Seq[AggPhaseEnforcer](
-      AggPhaseEnforcer.NONE,
-      AggPhaseEnforcer.ONE_PHASE,
-      AggPhaseEnforcer.TWO_PHASE
-    )
-  }
-}
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/UnionTest.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/UnionTest.scala
index 3f5726e..90ff097 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/UnionTest.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/UnionTest.scala
@@ -21,6 +21,7 @@ package org.apache.flink.table.plan.batch.sql
 import org.apache.flink.api.scala._
 import org.apache.flink.table.util.TableTestBase
 
+import org.apache.calcite.sql.SqlExplainLevel
 import org.junit.{Before, Test}
 
 // TODO add more union case after aggregation and join supported
@@ -59,7 +60,10 @@ class UnionTest extends TableTestBase {
         | UNION ALL
         | SELECT a, CAST(0 aS DECIMAL(2, 1)) FROM MyTable2)
       """.stripMargin
-    util.verifyPlanWithType(sqlQuery)
+    util.doVerifyPlan(sqlQuery,
+      explainLevel = SqlExplainLevel.EXPPLAN_ATTRIBUTES,
+      withRowType = true,
+      printPlanBefore = true)
   }
 
 }
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/ValuesTest.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/ValuesTest.scala
index 4e401e3..9dc7915 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/ValuesTest.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/ValuesTest.scala
@@ -20,6 +20,7 @@ package org.apache.flink.table.plan.batch.sql
 
 import org.apache.flink.table.util.TableTestBase
 
+import org.apache.calcite.sql.SqlExplainLevel
 import org.junit.Test
 
 class ValuesTest extends TableTestBase {
@@ -43,7 +44,12 @@ class ValuesTest extends TableTestBase {
 
   @Test
   def testDiffTypes(): Unit = {
-    util.verifyPlanWithType("SELECT * FROM (VALUES (1, 2.0), (3, CAST(4 AS BIGINT))) AS T(a, b)")
+    val sql = "SELECT * FROM (VALUES (1, 2.0), (3, CAST(4 AS BIGINT))) AS T(a, b)"
+    util.doVerifyPlan(
+      sql,
+      explainLevel = SqlExplainLevel.EXPPLAN_ATTRIBUTES,
+      withRowType = true,
+      printPlanBefore = true)
   }
 
 }
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/join/SingleRowJoinTest.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/join/SingleRowJoinTest.scala
index 612770a..63a493d 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/join/SingleRowJoinTest.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/batch/sql/join/SingleRowJoinTest.scala
@@ -22,8 +22,10 @@ import org.apache.flink.api.scala._
 import org.apache.flink.table.api.TableException
 import org.apache.flink.table.util.TableTestBase
 
-import org.junit.Test
+import org.junit.{Ignore, Test}
 
+// FIXME
+@Ignore("remove this after aggregate supports")
 class SingleRowJoinTest extends TableTestBase {
 
   @Test
@@ -58,8 +60,6 @@ class SingleRowJoinTest extends TableTestBase {
         |  (SELECT min(b1) AS b1, max(b2) AS b2 FROM B)
         |WHERE a1 < b1 AND a2 = b2
       """.stripMargin
-    // TODO NestedLoopJoin is more efficient than HashJoin for this query,
-    //  check this plan after metadata handler introduced
     util.verifyPlan(query)
   }
 
@@ -68,8 +68,6 @@ class SingleRowJoinTest extends TableTestBase {
     val util = batchTestUtil()
     util.addTableSource[(Long, Int)]("A", 'a1, 'a2)
     util.addTableSource[(Int, Int)]("B", 'b1, 'b2)
-    // TODO NestedLoopJoin is more efficient than HashJoin for this query,
-    //  check this plan after metadata handler introduced
     util.verifyPlan("SELECT a2 FROM A LEFT JOIN (SELECT COUNT(*) AS cnt FROM B) AS x  ON a1 = cnt")
   }
 
@@ -86,8 +84,6 @@ class SingleRowJoinTest extends TableTestBase {
     val util = batchTestUtil()
     util.addTableSource[(Long, Long)]("A", 'a1, 'a2)
     util.addTableSource[(Long, Long)]("B", 'b1, 'b2)
-    // TODO NestedLoopJoin is more efficient than HashJoin for this query,
-    //  check this plan after metadata handler introduced
     util.verifyPlan("SELECT a1 FROM (SELECT COUNT(*) AS cnt FROM B) RIGHT JOIN A ON cnt = a2")
   }
 
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/stream/sql/UnionTest.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/stream/sql/UnionTest.scala
index 42ccd5f..46a3bc8 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/stream/sql/UnionTest.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/stream/sql/UnionTest.scala
@@ -21,6 +21,7 @@ package org.apache.flink.table.plan.stream.sql
 import org.apache.flink.api.scala._
 import org.apache.flink.table.util.TableTestBase
 
+import org.apache.calcite.sql.SqlExplainLevel
 import org.junit.{Before, Test}
 
 // TODO add more union case after aggregation and join supported
@@ -59,7 +60,10 @@ class UnionTest extends TableTestBase {
         | UNION ALL
         | SELECT a, CAST(0 aS DECIMAL(2, 1)) FROM MyTable2)
       """.stripMargin
-    util.verifyPlanWithType(sqlQuery)
+    util.doVerifyPlan(sqlQuery,
+      explainLevel = SqlExplainLevel.EXPPLAN_ATTRIBUTES,
+      withRowType = true,
+      printPlanBefore = true)
   }
 
 }
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/stream/sql/ValuesTest.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/stream/sql/ValuesTest.scala
index 617972c..2d5e301 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/stream/sql/ValuesTest.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/plan/stream/sql/ValuesTest.scala
@@ -20,6 +20,7 @@ package org.apache.flink.table.plan.stream.sql
 
 import org.apache.flink.table.util.TableTestBase
 
+import org.apache.calcite.sql.SqlExplainLevel
 import org.junit.Test
 
 class ValuesTest extends TableTestBase {
@@ -43,7 +44,12 @@ class ValuesTest extends TableTestBase {
 
   @Test
   def testDiffTypes(): Unit = {
-    util.verifyPlanWithType("SELECT * FROM (VALUES (1, 2.0), (3, CAST(4 AS BIGINT))) AS T(a, b)")
+    val sql = "SELECT * FROM (VALUES (1, 2.0), (3, CAST(4 AS BIGINT))) AS T(a, b)"
+    util.doVerifyPlan(
+      sql,
+      explainLevel = SqlExplainLevel.EXPPLAN_ATTRIBUTES,
+      withRowType = true,
+      printPlanBefore = true)
   }
 
 }
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/util/TableTestBase.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/util/TableTestBase.scala
index 27fce55..fa9b337 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/util/TableTestBase.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/util/TableTestBase.scala
@@ -202,14 +202,6 @@ abstract class TableTestUtil(test: TableTestBase) {
       printPlanBefore = true)
   }
 
-  def verifyPlanWithType(sql: String): Unit = {
-    doVerifyPlan(
-      sql,
-      explainLevel = SqlExplainLevel.EXPPLAN_ATTRIBUTES,
-      withRowType = true,
-      printPlanBefore = true)
-  }
-
   def verifyExplain(): Unit = doVerifyExplain()
 
   def verifyExplain(sql: String): Unit = {