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 = {