You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by go...@apache.org on 2021/01/06 05:42:13 UTC

[flink] branch master updated (5351203 -> 4541707)

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

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


    from 5351203  [hotfix][tests] Remove ProgrammedSlotProvider
     new 53a888c  [FLINK-20737][table-planner-blink] Use RowType instead of RelDataType when building aggregate info
     new 683a2a7  [FLINK-20737][table-planner-blink] Introduce StreamPhysicalGroupAggregate, and make StreamExecGroupAggregate only extended from ExecNode
     new a44285a  [FLINK-20737][table-planner-blink] Introduce StreamPhysicalPythonGroupAggregate, and make StreamExecPythonGroupAggregate only extended from ExecNode
     new fa64127  [FLINK-20737][table-planner-blink] Introduce StreamPhysicalLocalGroupAggregate, and make StreamExecLocalGroupAggregate only extended from ExecNode
     new 85e9f80  [FLINK-20737][table-planner-blink] Introduce StreamPhysicalGlobalGroupAggregate, and make StreamExecGlobalGroupAggregate only extended from ExecNode
     new 1eaf54b  [FLINK-20737][table-planner-blink] Introduce StreamPhysicalIncrementalGroupAggregate, and make StreamExecIncrementalGroupAggregate only extended from ExecNode
     new c96d1ff  [FLINK-20737][table-planner-blink] Introduce StreamPhysicalGroupTableAggregate, and make StreamExecGroupTableAggregate only extended from ExecNode
     new 4541707  [FLINK-20737][table-planner-blink] Introduce StreamPhysicalPythonGroupTableAggregate, and make StreamExecPythonGroupTableAggregate only extended from ExecNode

The 8 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../stream/StreamExecGlobalGroupAggregate.java     | 226 +++++++++++++++++++++
 .../exec/stream/StreamExecGroupAggregate.java      | 202 ++++++++++++++++++
 .../exec/stream/StreamExecGroupTableAggregate.java | 166 +++++++++++++++
 .../StreamExecIncrementalGroupAggregate.java       | 188 +++++++++++++++++
 .../exec/stream/StreamExecLocalGroupAggregate.java | 129 ++++++++++++
 .../batch/BatchExecPythonAggregateRule.java        |   5 +-
 .../batch/BatchExecPythonWindowAggregateRule.java  |   5 +-
 ...=> StreamPhysicalPythonGroupAggregateRule.java} |  22 +-
 ...reamPhysicalPythonGroupTableAggregateRule.java} |  21 +-
 .../table/planner/codegen/MatchCodeGenerator.scala |   2 +-
 .../plan/metadata/FlinkRelMdColumnInterval.scala   |  37 ++--
 .../plan/metadata/FlinkRelMdColumnUniqueness.scala |   6 +-
 .../FlinkRelMdFilteredColumnInterval.scala         |  10 +-
 .../metadata/FlinkRelMdModifiedMonotonicity.scala  |  10 +-
 .../plan/metadata/FlinkRelMdUniqueKeys.scala       |   6 +-
 .../common/CommonExecPythonAggregate.scala}        |   8 +-
 .../stream/StreamExecPythonGroupAggregate.scala    | 114 ++++-------
 .../StreamExecPythonGroupTableAggregate.scala      |  89 ++++----
 .../batch/BatchExecHashAggregateBase.scala         |   2 +-
 .../batch/BatchExecHashWindowAggregateBase.scala   |   2 +-
 .../physical/batch/BatchExecOverAggregate.scala    |  18 +-
 .../batch/BatchExecPythonGroupAggregate.scala      |   6 +-
 .../BatchExecPythonGroupWindowAggregate.scala      |   6 +-
 .../batch/BatchExecPythonOverAggregate.scala       |   4 +-
 .../batch/BatchExecSortAggregateBase.scala         |   2 +-
 .../batch/BatchExecSortWindowAggregateBase.scala   |   2 +-
 .../stream/StreamExecGlobalGroupAggregate.scala    | 207 -------------------
 .../physical/stream/StreamExecGroupAggregate.scala | 192 -----------------
 .../stream/StreamExecGroupTableAggregate.scala     | 140 -------------
 .../StreamExecGroupWindowAggregateBase.scala       |   2 +-
 .../StreamExecIncrementalGroupAggregate.scala      | 205 -------------------
 .../stream/StreamExecLocalGroupAggregate.scala     | 142 -------------
 .../physical/stream/StreamExecOverAggregate.scala  |   8 +-
 .../StreamExecPythonGroupWindowAggregate.scala     |   4 +-
 .../stream/StreamExecPythonOverAggregate.scala     |  13 +-
 .../StreamPhysicalGlobalGroupAggregate.scala       | 108 ++++++++++
 .../stream/StreamPhysicalGroupAggregate.scala      |  97 +++++++++
 ...cala => StreamPhysicalGroupAggregateBase.scala} |   2 +-
 .../stream/StreamPhysicalGroupTableAggregate.scala |  76 +++++++
 ...=> StreamPhysicalGroupTableAggregateBase.scala} |  13 +-
 .../StreamPhysicalIncrementalGroupAggregate.scala  | 132 ++++++++++++
 .../stream/StreamPhysicalLocalGroupAggregate.scala | 103 ++++++++++
 ...la => StreamPhysicalPythonGroupAggregate.scala} |  55 +++--
 .../StreamPhysicalPythonGroupTableAggregate.scala  |  76 +++++++
 .../FlinkChangelogModeInferenceProgram.scala       |  12 +-
 .../planner/plan/rules/FlinkStreamRuleSets.scala   |   8 +-
 .../physical/batch/BatchExecAggRuleBase.scala      |   2 +-
 .../physical/batch/BatchExecHashAggRule.scala      |   4 +-
 .../batch/BatchExecOverAggregateRule.scala         |   4 +-
 .../physical/batch/BatchExecSortAggRule.scala      |   4 +-
 .../batch/BatchExecWindowAggregateRule.scala       |   2 +-
 .../physical/batch/EnforceLocalAggRuleBase.scala   |   5 +-
 .../physical/stream/IncrementalAggregateRule.scala | 118 ++++-------
 ...cala => StreamPhysicalGroupAggregateRule.scala} |  19 +-
 ...=> StreamPhysicalGroupTableAggregateRule.scala} |  23 ++-
 .../stream/TwoStageOptimizedAggregateRule.scala    |  97 ++++-----
 .../planner/plan/utils/AggFunctionFactory.scala    |  46 ++---
 .../table/planner/plan/utils/AggregateUtil.scala   | 213 ++++++++++++-------
 .../plan/metadata/FlinkRelMdHandlerTestBase.scala  |  60 +++---
 .../plan/stream/table/PythonAggregateTest.scala    |   5 +-
 60 files changed, 2045 insertions(+), 1440 deletions(-)
 create mode 100644 flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGlobalGroupAggregate.java
 create mode 100644 flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGroupAggregate.java
 create mode 100644 flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGroupTableAggregate.java
 create mode 100644 flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecIncrementalGroupAggregate.java
 create mode 100644 flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecLocalGroupAggregate.java
 rename flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/{StreamExecPythonGroupAggregateRule.java => StreamPhysicalPythonGroupAggregateRule.java} (88%)
 rename flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/{StreamExecPythonGroupTableAggregateRule.java => StreamPhysicalPythonGroupTableAggregateRule.java} (87%)
 rename flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/{common/CommonPythonAggregate.scala => exec/common/CommonExecPythonAggregate.scala} (98%)
 rename flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/{physical => exec}/stream/StreamExecPythonGroupAggregate.scala (65%)
 rename flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/{physical => exec}/stream/StreamExecPythonGroupTableAggregate.scala (72%)
 delete mode 100644 flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGlobalGroupAggregate.scala
 delete mode 100644 flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupAggregate.scala
 delete mode 100644 flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupTableAggregate.scala
 delete mode 100644 flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
 delete mode 100644 flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecLocalGroupAggregate.scala
 create mode 100644 flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGlobalGroupAggregate.scala
 create mode 100644 flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupAggregate.scala
 rename flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/{StreamExecGroupAggregateBase.scala => StreamPhysicalGroupAggregateBase.scala} (98%)
 create mode 100644 flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupTableAggregate.scala
 copy flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/{StreamExecGroupTableAggregateBase.scala => StreamPhysicalGroupTableAggregateBase.scala} (85%)
 create mode 100644 flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalIncrementalGroupAggregate.scala
 create mode 100644 flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalLocalGroupAggregate.scala
 rename flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/{StreamExecGroupTableAggregateBase.scala => StreamPhysicalPythonGroupAggregate.scala} (52%)
 create mode 100644 flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalPythonGroupTableAggregate.scala
 rename flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/{StreamExecGroupAggregateRule.scala => StreamPhysicalGroupAggregateRule.scala} (88%)
 rename flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/{StreamExecGroupTableAggregateRule.scala => StreamPhysicalGroupTableAggregateRule.scala} (84%)

[flink] 03/08: [FLINK-20737][table-planner-blink] Introduce StreamPhysicalPythonGroupAggregate, and make StreamExecPythonGroupAggregate only extended from ExecNode

Posted by go...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit a44285a4a1d0836e99e90244894c57637e81ab58
Author: godfreyhe <go...@163.com>
AuthorDate: Thu Dec 24 19:42:37 2020 +0800

    [FLINK-20737][table-planner-blink] Introduce StreamPhysicalPythonGroupAggregate, and make StreamExecPythonGroupAggregate only extended from ExecNode
    
    This closes #14478
---
 ...=> StreamPhysicalPythonGroupAggregateRule.java} |  22 ++--
 .../common/CommonExecPythonAggregate.scala}        |   8 +-
 .../stream/StreamExecPythonGroupAggregate.scala    | 114 ++++++++-------------
 .../batch/BatchExecPythonGroupAggregate.scala      |   6 +-
 .../BatchExecPythonGroupWindowAggregate.scala      |   6 +-
 .../batch/BatchExecPythonOverAggregate.scala       |   4 +-
 .../StreamExecPythonGroupTableAggregate.scala      |   4 +-
 .../StreamExecPythonGroupWindowAggregate.scala     |   4 +-
 .../stream/StreamExecPythonOverAggregate.scala     |  13 ++-
 .../StreamPhysicalPythonGroupAggregate.scala       |  92 +++++++++++++++++
 .../FlinkChangelogModeInferenceProgram.scala       |   4 +-
 .../planner/plan/rules/FlinkStreamRuleSets.scala   |   2 +-
 .../plan/stream/table/PythonAggregateTest.scala    |   5 +-
 13 files changed, 171 insertions(+), 113 deletions(-)

diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecPythonGroupAggregateRule.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalPythonGroupAggregateRule.java
similarity index 88%
rename from flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecPythonGroupAggregateRule.java
rename to flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalPythonGroupAggregateRule.java
index cc2f87c..602bdef 100644
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecPythonGroupAggregateRule.java
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalPythonGroupAggregateRule.java
@@ -22,9 +22,10 @@ import org.apache.flink.table.api.TableException;
 import org.apache.flink.table.functions.python.PythonFunctionKind;
 import org.apache.flink.table.planner.plan.nodes.FlinkConventions;
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalAggregate;
-import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamExecPythonGroupAggregate;
+import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamPhysicalPythonGroupAggregate;
 import org.apache.flink.table.planner.plan.trait.FlinkRelDistribution;
 import org.apache.flink.table.planner.plan.utils.PythonUtil;
+import org.apache.flink.table.planner.utils.JavaScalaConversionUtil;
 
 import org.apache.calcite.plan.RelOptRule;
 import org.apache.calcite.plan.RelOptRuleCall;
@@ -36,21 +37,20 @@ import org.apache.calcite.rel.core.AggregateCall;
 
 import java.util.List;
 
-import scala.collection.JavaConverters;
-
 /**
- * Rule to convert a {@link FlinkLogicalAggregate} into a {@link StreamExecPythonGroupAggregate}.
+ * Rule to convert a {@link FlinkLogicalAggregate} into a {@link
+ * StreamPhysicalPythonGroupAggregate}.
  */
-public class StreamExecPythonGroupAggregateRule extends ConverterRule {
+public class StreamPhysicalPythonGroupAggregateRule extends ConverterRule {
 
-    public static final RelOptRule INSTANCE = new StreamExecPythonGroupAggregateRule();
+    public static final RelOptRule INSTANCE = new StreamPhysicalPythonGroupAggregateRule();
 
-    public StreamExecPythonGroupAggregateRule() {
+    public StreamPhysicalPythonGroupAggregateRule() {
         super(
                 FlinkLogicalAggregate.class,
                 FlinkConventions.LOGICAL(),
                 FlinkConventions.STREAM_PHYSICAL(),
-                "StreamExecPythonGroupAggregateRule");
+                "StreamPhysicalPythonGroupAggregateRule");
     }
 
     @Override
@@ -111,14 +111,12 @@ public class StreamExecPythonGroupAggregateRule extends ConverterRule {
                 rel.getTraitSet().replace(FlinkConventions.STREAM_PHYSICAL());
         RelNode newInput = RelOptRule.convert(agg.getInput(), requiredTraitSet);
 
-        return new StreamExecPythonGroupAggregate(
+        return new StreamPhysicalPythonGroupAggregate(
                 rel.getCluster(),
                 providedTraitSet,
                 newInput,
                 rel.getRowType(),
                 agg.getGroupSet().toArray(),
-                JavaConverters.asScalaIteratorConverter(agg.getAggCallList().iterator())
-                        .asScala()
-                        .toSeq());
+                JavaScalaConversionUtil.toScala(agg.getAggCallList()));
     }
 }
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/common/CommonPythonAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/exec/common/CommonExecPythonAggregate.scala
similarity index 98%
rename from flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/common/CommonPythonAggregate.scala
rename to flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/exec/common/CommonExecPythonAggregate.scala
index b06e21d..0685296 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/common/CommonPythonAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/exec/common/CommonExecPythonAggregate.scala
@@ -16,9 +16,8 @@
  * limitations under the License.
  */
 
-package org.apache.flink.table.planner.plan.nodes.common
+package org.apache.flink.table.planner.plan.nodes.exec.common
 
-import org.apache.calcite.rel.core.AggregateCall
 import org.apache.flink.table.api.TableException
 import org.apache.flink.table.api.dataview.{DataView, ListView, MapView}
 import org.apache.flink.table.functions.UserDefinedFunction
@@ -27,15 +26,18 @@ import org.apache.flink.table.planner.functions.aggfunctions.Sum0AggFunction._
 import org.apache.flink.table.planner.functions.aggfunctions._
 import org.apache.flink.table.planner.functions.bridging.BridgingSqlAggFunction
 import org.apache.flink.table.planner.functions.utils.AggSqlFunction
+import org.apache.flink.table.planner.plan.nodes.common.CommonPythonBase
 import org.apache.flink.table.planner.plan.utils.AggregateInfoList
 import org.apache.flink.table.planner.typeutils.DataViewUtils.{DataViewSpec, ListViewSpec, MapViewSpec}
 import org.apache.flink.table.types.logical.{RowType, StructuredType}
 import org.apache.flink.table.types.{DataType, FieldsDataType}
 
+import org.apache.calcite.rel.core.AggregateCall
+
 import scala.collection.JavaConversions._
 import scala.collection.mutable
 
-trait CommonPythonAggregate extends CommonPythonBase {
+trait CommonExecPythonAggregate extends CommonPythonBase {
 
   /**
     * For batch execution we extract the PythonFunctionInfo from AggregateCall.
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecPythonGroupAggregate.scala
similarity index 65%
rename from flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupAggregate.scala
rename to flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecPythonGroupAggregate.scala
index 3570ca1..eb36a22 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecPythonGroupAggregate.scala
@@ -16,7 +16,7 @@
  * limitations under the License.
  */
 
-package org.apache.flink.table.planner.plan.nodes.physical.stream
+package org.apache.flink.table.planner.plan.nodes.exec.stream
 
 import org.apache.flink.api.dag.Transformation
 import org.apache.flink.configuration.Configuration
@@ -25,74 +25,41 @@ import org.apache.flink.streaming.api.operators.OneInputStreamOperator
 import org.apache.flink.streaming.api.transformations.OneInputTransformation
 import org.apache.flink.table.data.RowData
 import org.apache.flink.table.functions.python.PythonAggregateFunctionInfo
-import org.apache.flink.table.planner.calcite.FlinkTypeFactory
-import org.apache.flink.table.planner.delegation.StreamPlanner
-import org.apache.flink.table.planner.plan.nodes.common.CommonPythonAggregate
-import org.apache.flink.table.planner.plan.nodes.exec.LegacyStreamExecNode
-import org.apache.flink.table.planner.plan.utils._
+import org.apache.flink.table.planner.delegation.PlannerBase
+import org.apache.flink.table.planner.plan.nodes.exec.common.CommonExecPythonAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.{ExecEdge, ExecNode, ExecNodeBase}
+import org.apache.flink.table.planner.plan.utils.{AggregateUtil, KeySelectorUtil}
 import org.apache.flink.table.planner.typeutils.DataViewUtils.DataViewSpec
+import org.apache.flink.table.planner.utils.Logging
 import org.apache.flink.table.runtime.typeutils.InternalTypeInfo
 import org.apache.flink.table.types.logical.RowType
 
-import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
-import org.apache.calcite.rel.`type`.RelDataType
 import org.apache.calcite.rel.core.AggregateCall
-import org.apache.calcite.rel.{RelNode, RelWriter}
 
-import java.util
+import java.util.Collections
 
 /**
-  * Stream physical RelNode for Python unbounded group aggregate.
-  *
-  * @see [[StreamPhysicalGroupAggregateBase]] for more info.
-  */
+ * Stream [[ExecNode]] for Python unbounded group aggregate.
+ *
+ * <p>Note: This class can't be ported to Java,
+ * because java class can't extend scala interface with default implementation.
+ * FLINK-20750 will port this class to Java.
+ */
 class StreamExecPythonGroupAggregate(
-    cluster: RelOptCluster,
-    traitSet: RelTraitSet,
-    inputRel: RelNode,
-    outputRowType: RelDataType,
-    val grouping: Array[Int],
-    val aggCalls: Seq[AggregateCall])
-  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel)
-  with LegacyStreamExecNode[RowData]
-  with CommonPythonAggregate {
-
-  val aggInfoList: AggregateInfoList = AggregateUtil.deriveAggregateInfoList(
-    this,
-    grouping.length,
-    aggCalls)
-
-  override def requireWatermark: Boolean = false
-
-  override def deriveRowType(): RelDataType = outputRowType
-
-  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
-    new StreamExecPythonGroupAggregate(
-      cluster,
-      traitSet,
-      inputs.get(0),
-      outputRowType,
-      grouping,
-      aggCalls)
-  }
-
-  override def explainTerms(pw: RelWriter): RelWriter = {
-    val inputRowType = getInput.getRowType
-    super.explainTerms(pw)
-      .itemIf("groupBy",
-        RelExplainUtil.fieldToString(grouping, inputRowType), grouping.nonEmpty)
-      .item("select", RelExplainUtil.streamGroupAggregationToString(
-        inputRowType,
-        getRowType,
-        aggInfoList,
-        grouping))
-  }
-
-  //~ ExecNode methods -----------------------------------------------------------
-
-  override protected def translateToPlanInternal(
-      planner: StreamPlanner): Transformation[RowData] = {
-
+    grouping: Array[Int],
+    aggCalls: Seq[AggregateCall],
+    aggCallNeedRetractions: Array[Boolean],
+    generateUpdateBefore: Boolean,
+    needRetraction: Boolean,
+    inputEdge: ExecEdge,
+    outputType: RowType,
+    description: String)
+  extends ExecNodeBase[RowData](Collections.singletonList(inputEdge), outputType, description)
+  with StreamExecNode[RowData]
+  with CommonExecPythonAggregate
+  with Logging {
+
+  override protected def translateToPlanInternal(planner: PlannerBase): Transformation[RowData] = {
     val tableConfig = planner.getTableConfig
 
     if (grouping.length > 0 && tableConfig.getMinIdleStateRetentionTime < 0) {
@@ -101,16 +68,17 @@ class StreamExecPythonGroupAggregate(
         "state size. You may specify a retention time of 0 to not clean up the state.")
     }
 
-    val inputTransformation = getInputNodes.get(0).translateToPlan(planner)
-      .asInstanceOf[Transformation[RowData]]
-
-    val outRowType = FlinkTypeFactory.toLogicalRowType(outputRowType)
-    val inputRowType = FlinkTypeFactory.toLogicalRowType(getInput.getRowType)
-
-    val generateUpdateBefore = ChangelogPlanUtils.generateUpdateBefore(this)
+    val inputNode = getInputNodes.get(0).asInstanceOf[ExecNode[RowData]]
+    val inputTransformation = inputNode.translateToPlan(planner)
+    val inputRowType = inputNode.getOutputType.asInstanceOf[RowType]
 
+    val aggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
+      inputRowType,
+      aggCalls,
+      aggCallNeedRetractions,
+      needRetraction,
+      isStateBackendDataViews = true)
     val inputCountIndex = aggInfoList.getIndexOfCountStar
-
     val countStarInserted = aggInfoList.countStarInserted
 
     var (pythonFunctionInfos, dataViewSpecs) =
@@ -123,7 +91,7 @@ class StreamExecPythonGroupAggregate(
     val operator = getPythonAggregateFunctionOperator(
       getConfig(planner.getExecEnv, tableConfig),
       inputRowType,
-      outRowType,
+      outputType,
       pythonFunctionInfos,
       dataViewSpecs,
       tableConfig.getMinIdleStateRetentionTime,
@@ -133,16 +101,14 @@ class StreamExecPythonGroupAggregate(
       inputCountIndex,
       countStarInserted)
 
-    val selector = KeySelectorUtil.getRowDataSelector(
-      grouping,
-      InternalTypeInfo.of(inputRowType))
+    val selector = KeySelectorUtil.getRowDataSelector(grouping, InternalTypeInfo.of(inputRowType))
 
     // partitioned aggregation
     val ret = new OneInputTransformation(
       inputTransformation,
-      getRelDetailedDescription,
+      getDesc,
       operator,
-      InternalTypeInfo.of(outRowType),
+      InternalTypeInfo.of(outputType),
       inputTransformation.getParallelism)
 
     if (inputsContainSingleton()) {
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonGroupAggregate.scala
index f0d02c6..54ba618 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonGroupAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonGroupAggregate.scala
@@ -29,8 +29,8 @@ import org.apache.flink.table.functions.python.PythonFunctionInfo
 import org.apache.flink.table.planner.calcite.FlinkTypeFactory
 import org.apache.flink.table.planner.delegation.BatchPlanner
 import org.apache.flink.table.planner.plan.`trait`.{FlinkRelDistribution, FlinkRelDistributionTraitDef}
-import org.apache.flink.table.planner.plan.nodes.common.CommonPythonAggregate
-import org.apache.flink.table.planner.plan.nodes.exec.{LegacyBatchExecNode, ExecEdge}
+import org.apache.flink.table.planner.plan.nodes.exec.common.CommonExecPythonAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.{ExecEdge, LegacyBatchExecNode}
 import org.apache.flink.table.planner.plan.nodes.physical.batch.BatchExecPythonGroupAggregate.ARROW_PYTHON_AGGREGATE_FUNCTION_OPERATOR_NAME
 import org.apache.flink.table.planner.plan.rules.physical.batch.BatchExecJoinRuleBase
 import org.apache.flink.table.planner.plan.utils.{FlinkRelOptUtil, RelExplainUtil}
@@ -75,7 +75,7 @@ class BatchExecPythonGroupAggregate(
     isMerge = false,
     isFinal = true)
   with LegacyBatchExecNode[RowData]
-  with CommonPythonAggregate {
+  with CommonExecPythonAggregate {
 
   override def explainTerms(pw: RelWriter): RelWriter =
     super.explainTerms(pw)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonGroupWindowAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonGroupWindowAggregate.scala
index 989e053..ab3ce2c 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonGroupWindowAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonGroupWindowAggregate.scala
@@ -34,8 +34,8 @@ import org.apache.flink.table.planner.delegation.BatchPlanner
 import org.apache.flink.table.planner.expressions.{PlannerRowtimeAttribute, PlannerWindowEnd, PlannerWindowStart}
 import org.apache.flink.table.planner.plan.cost.{FlinkCost, FlinkCostFactory}
 import org.apache.flink.table.planner.plan.logical.LogicalWindow
-import org.apache.flink.table.planner.plan.nodes.common.CommonPythonAggregate
-import org.apache.flink.table.planner.plan.nodes.exec.{LegacyBatchExecNode, ExecEdge}
+import org.apache.flink.table.planner.plan.nodes.exec.common.CommonExecPythonAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.{ExecEdge, LegacyBatchExecNode}
 import org.apache.flink.table.planner.plan.nodes.physical.batch.BatchExecPythonGroupWindowAggregate.ARROW_PYTHON_GROUP_WINDOW_AGGREGATE_FUNCTION_OPERATOR_NAME
 import org.apache.flink.table.runtime.typeutils.InternalTypeInfo
 import org.apache.flink.table.types.logical.RowType
@@ -84,7 +84,7 @@ class BatchExecPythonGroupWindowAggregate(
     false,
     true)
   with LegacyBatchExecNode[RowData]
-  with CommonPythonAggregate {
+  with CommonExecPythonAggregate {
 
   override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
     new BatchExecPythonGroupWindowAggregate(
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonOverAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonOverAggregate.scala
index dea0d33..9c62a8b 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonOverAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecPythonOverAggregate.scala
@@ -28,7 +28,7 @@ import org.apache.flink.table.functions.UserDefinedFunction
 import org.apache.flink.table.functions.python.PythonFunctionInfo
 import org.apache.flink.table.planner.calcite.FlinkTypeFactory
 import org.apache.flink.table.planner.delegation.BatchPlanner
-import org.apache.flink.table.planner.plan.nodes.common.CommonPythonAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.common.CommonExecPythonAggregate
 import org.apache.flink.table.planner.plan.nodes.physical.batch.BatchExecPythonOverAggregate.ARROW_PYTHON_OVER_WINDOW_AGGREGATE_FUNCTION_OPERATOR_NAME
 import org.apache.flink.table.planner.plan.utils.OverAggregateUtil.getLongBoundary
 import org.apache.flink.table.runtime.typeutils.InternalTypeInfo
@@ -73,7 +73,7 @@ class BatchExecPythonOverAggregate(
     nullIsLasts,
     windowGroupToAggCallToAggFunction,
     logicWindow)
-  with CommonPythonAggregate {
+  with CommonExecPythonAggregate {
 
   override def copy(traitSet: RelTraitSet, inputs: java.util.List[RelNode]): RelNode = {
     new BatchExecPythonOverAggregate(
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupTableAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupTableAggregate.scala
index c92359f..cab5a46 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupTableAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupTableAggregate.scala
@@ -26,7 +26,7 @@ import org.apache.flink.table.data.RowData
 import org.apache.flink.table.functions.python.PythonAggregateFunctionInfo
 import org.apache.flink.table.planner.calcite.FlinkTypeFactory
 import org.apache.flink.table.planner.delegation.StreamPlanner
-import org.apache.flink.table.planner.plan.nodes.common.CommonPythonAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.common.CommonExecPythonAggregate
 import org.apache.flink.table.planner.plan.utils.{ChangelogPlanUtils, KeySelectorUtil}
 import org.apache.flink.table.planner.typeutils.DataViewUtils.DataViewSpec
 import org.apache.flink.table.runtime.typeutils.InternalTypeInfo
@@ -56,7 +56,7 @@ class StreamExecPythonGroupTableAggregate(
     outputRowType,
     grouping,
     aggCalls)
-  with CommonPythonAggregate {
+  with CommonExecPythonAggregate {
 
   override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
     new StreamExecPythonGroupTableAggregate(
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupWindowAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupWindowAggregate.scala
index 54479ba..ee54572 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupWindowAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupWindowAggregate.scala
@@ -31,7 +31,7 @@ import org.apache.flink.table.planner.calcite.FlinkTypeFactory
 import org.apache.flink.table.planner.delegation.StreamPlanner
 import org.apache.flink.table.planner.expressions.{PlannerProctimeAttribute, PlannerRowtimeAttribute, PlannerWindowEnd, PlannerWindowStart}
 import org.apache.flink.table.planner.plan.logical.{LogicalWindow, SlidingGroupWindow, TumblingGroupWindow}
-import org.apache.flink.table.planner.plan.nodes.common.CommonPythonAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.common.CommonExecPythonAggregate
 import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamExecPythonGroupWindowAggregate.ARROW_STREAM_PYTHON_GROUP_WINDOW_AGGREGATE_FUNCTION_OPERATOR_NAME
 import org.apache.flink.table.planner.plan.utils.AggregateUtil._
 import org.apache.flink.table.planner.plan.utils.{KeySelectorUtil, WindowEmitStrategy}
@@ -73,7 +73,7 @@ class StreamExecPythonGroupWindowAggregate(
     inputTimeFieldIndex,
     emitStrategy,
     "PythonAggregate")
-  with CommonPythonAggregate {
+  with CommonExecPythonAggregate {
 
   override def copy(traitSet: RelTraitSet, inputs: java.util.List[RelNode]): RelNode = {
     new StreamExecPythonGroupWindowAggregate(
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonOverAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonOverAggregate.scala
index 930ea87..e7d9d32 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonOverAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonOverAggregate.scala
@@ -27,13 +27,12 @@ import org.apache.flink.table.data.RowData
 import org.apache.flink.table.functions.python.PythonFunctionInfo
 import org.apache.flink.table.planner.calcite.FlinkTypeFactory
 import org.apache.flink.table.planner.delegation.StreamPlanner
-import org.apache.flink.table.planner.plan.nodes.common.CommonPythonAggregate
-import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamExecPythonOverAggregate.{
+import org.apache.flink.table.planner.plan.nodes.exec.common.CommonExecPythonAggregate
+import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamExecPythonOverAggregate
+.{ARROW_PYTHON_OVER_WINDOW_RANGE_PROC_TIME_AGGREGATE_FUNCTION_OPERATOR_NAME,
   ARROW_PYTHON_OVER_WINDOW_RANGE_ROW_TIME_AGGREGATE_FUNCTION_OPERATOR_NAME,
-  ARROW_PYTHON_OVER_WINDOW_RANGE_PROC_TIME_AGGREGATE_FUNCTION_OPERATOR_NAME,
-  ARROW_PYTHON_OVER_WINDOW_ROWS_ROW_TIME_AGGREGATE_FUNCTION_OPERATOR_NAME,
-  ARROW_PYTHON_OVER_WINDOW_ROWS_PROC_TIME_AGGREGATE_FUNCTION_OPERATOR_NAME
-}
+  ARROW_PYTHON_OVER_WINDOW_ROWS_PROC_TIME_AGGREGATE_FUNCTION_OPERATOR_NAME,
+  ARROW_PYTHON_OVER_WINDOW_ROWS_ROW_TIME_AGGREGATE_FUNCTION_OPERATOR_NAME}
 import org.apache.flink.table.planner.plan.utils.{KeySelectorUtil, OverAggregateUtil}
 import org.apache.flink.table.runtime.typeutils.InternalTypeInfo
 import org.apache.flink.table.types.logical.RowType
@@ -66,7 +65,7 @@ class StreamExecPythonOverAggregate(
     outputRowType,
     inputRowType,
     logicWindow)
-  with CommonPythonAggregate {
+  with CommonExecPythonAggregate {
 
   override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
     new StreamExecPythonOverAggregate(
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalPythonGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalPythonGroupAggregate.scala
new file mode 100644
index 0000000..029779f
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalPythonGroupAggregate.scala
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.flink.table.planner.plan.nodes.physical.stream
+
+import org.apache.flink.table.planner.calcite.FlinkTypeFactory
+import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecPythonGroupAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.{ExecEdge, ExecNode}
+import org.apache.flink.table.planner.plan.utils._
+
+import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
+import org.apache.calcite.rel.`type`.RelDataType
+import org.apache.calcite.rel.core.AggregateCall
+import org.apache.calcite.rel.{RelNode, RelWriter}
+
+import java.util
+
+/**
+  * Stream physical RelNode for Python unbounded group aggregate.
+  *
+  * @see [[StreamPhysicalGroupAggregateBase]] for more info.
+  */
+class StreamPhysicalPythonGroupAggregate(
+    cluster: RelOptCluster,
+    traitSet: RelTraitSet,
+    inputRel: RelNode,
+    outputRowType: RelDataType,
+    val grouping: Array[Int],
+    val aggCalls: Seq[AggregateCall])
+  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel) {
+
+  private lazy val aggInfoList =
+    AggregateUtil.deriveAggregateInfoList(this, grouping.length, aggCalls)
+
+  override def requireWatermark: Boolean = false
+
+  override def deriveRowType(): RelDataType = outputRowType
+
+  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
+    new StreamPhysicalPythonGroupAggregate(
+      cluster,
+      traitSet,
+      inputs.get(0),
+      outputRowType,
+      grouping,
+      aggCalls)
+  }
+
+  override def explainTerms(pw: RelWriter): RelWriter = {
+    val inputRowType = getInput.getRowType
+    super.explainTerms(pw)
+      .itemIf("groupBy",
+        RelExplainUtil.fieldToString(grouping, inputRowType), grouping.nonEmpty)
+      .item("select", RelExplainUtil.streamGroupAggregationToString(
+        inputRowType,
+        getRowType,
+        aggInfoList,
+        grouping))
+  }
+
+  override def translateToExecNode(): ExecNode[_] = {
+    val aggCallNeedRetractions =
+      AggregateUtil.deriveAggCallNeedRetractions(this, grouping.length, aggCalls)
+    val generateUpdateBefore = ChangelogPlanUtils.generateUpdateBefore(this)
+    val needRetraction = !ChangelogPlanUtils.inputInsertOnly(this)
+    new StreamExecPythonGroupAggregate(
+      grouping,
+      aggCalls,
+      aggCallNeedRetractions,
+      generateUpdateBefore,
+      needRetraction,
+      ExecEdge.DEFAULT,
+      FlinkTypeFactory.toLogicalRowType(getRowType),
+      getRelDetailedDescription
+    )
+  }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
index 8d276ca..2e862e1 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
@@ -185,7 +185,7 @@ class FlinkChangelogModeInferenceProgram extends FlinkOptimizeProgram[StreamOpti
         createNewNode(
           tagg, children, ModifyKindSetTrait.ALL_CHANGES, requiredTrait, requester)
 
-      case agg: StreamExecPythonGroupAggregate =>
+      case agg: StreamPhysicalPythonGroupAggregate =>
         // agg support all changes in input
         val children = visitChildren(agg, ModifyKindSetTrait.ALL_CHANGES)
         val inputModifyKindSet = getModifyKindSet(children.head)
@@ -462,7 +462,7 @@ class FlinkChangelogModeInferenceProgram extends FlinkOptimizeProgram[StreamOpti
         visitSink(sink, sinkRequiredTraits)
 
       case _: StreamPhysicalGroupAggregate | _: StreamExecGroupTableAggregate |
-           _: StreamPhysicalLimit | _: StreamExecPythonGroupAggregate |
+           _: StreamPhysicalLimit | _: StreamPhysicalPythonGroupAggregate |
            _: StreamExecPythonGroupTableAggregate =>
         // Aggregate, TableAggregate and Limit requires update_before if there are updates
         val requiredChildTrait = beforeAfterOrNone(getModifyKindSet(rel.getInput(0)))
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
index d7c695d..4fc6e04 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
@@ -422,7 +422,7 @@ object FlinkStreamRuleSets {
     // group agg
     StreamPhysicalGroupAggregateRule.INSTANCE,
     StreamExecGroupTableAggregateRule.INSTANCE,
-    StreamExecPythonGroupAggregateRule.INSTANCE,
+    StreamPhysicalPythonGroupAggregateRule.INSTANCE,
     StreamExecPythonGroupTableAggregateRule.INSTANCE,
     // over agg
     StreamExecOverAggregateRule.INSTANCE,
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/stream/table/PythonAggregateTest.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/stream/table/PythonAggregateTest.scala
index 4258824..4c26534 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/stream/table/PythonAggregateTest.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/stream/table/PythonAggregateTest.scala
@@ -22,11 +22,12 @@ import org.apache.flink.api.java.tuple.Tuple1
 import org.apache.flink.api.scala._
 import org.apache.flink.table.api._
 import org.apache.flink.table.api.dataview.{ListView, MapView}
-import org.apache.flink.table.planner.plan.nodes.common.CommonPythonAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.common.CommonExecPythonAggregate
 import org.apache.flink.table.planner.runtime.utils.JavaUserDefinedAggFunctions.TestPythonAggregateFunction
 import org.apache.flink.table.planner.typeutils.DataViewUtils.{DataViewSpec, ListViewSpec, MapViewSpec}
 import org.apache.flink.table.planner.utils.TableTestBase
 import org.apache.flink.table.types.DataType
+
 import org.junit.Assert.assertEquals
 import org.junit.Test
 
@@ -115,7 +116,7 @@ class PythonAggregateTest extends TableTestBase {
   }
 }
 
-object TestCommonPythonAggregate extends CommonPythonAggregate {
+object TestCommonPythonAggregate extends CommonExecPythonAggregate {
   def extractDataViewSpecs(accType: DataType): Array[DataViewSpec] = {
     extractDataViewSpecs(0, accType)
   }

[flink] 06/08: [FLINK-20737][table-planner-blink] Introduce StreamPhysicalIncrementalGroupAggregate, and make StreamExecIncrementalGroupAggregate only extended from ExecNode

Posted by go...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 1eaf54b73de34fe86057675be090032746cd6049
Author: godfreyhe <go...@163.com>
AuthorDate: Wed Dec 23 16:58:38 2020 +0800

    [FLINK-20737][table-planner-blink] Introduce StreamPhysicalIncrementalGroupAggregate, and make StreamExecIncrementalGroupAggregate only extended from ExecNode
    
    This closes #14478
---
 .../StreamExecIncrementalGroupAggregate.java       | 188 +++++++++++++++++++
 .../plan/metadata/FlinkRelMdColumnInterval.scala   |   8 +-
 .../metadata/FlinkRelMdModifiedMonotonicity.scala  |   2 +-
 .../StreamExecIncrementalGroupAggregate.scala      | 205 ---------------------
 .../StreamPhysicalGlobalGroupAggregate.scala       |   4 +-
 .../StreamPhysicalIncrementalGroupAggregate.scala  | 132 +++++++++++++
 .../physical/stream/IncrementalAggregateRule.scala |  73 +++-----
 .../table/planner/plan/utils/AggregateUtil.scala   |  59 +++++-
 8 files changed, 407 insertions(+), 264 deletions(-)

diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecIncrementalGroupAggregate.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecIncrementalGroupAggregate.java
new file mode 100644
index 0000000..cab48e4
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecIncrementalGroupAggregate.java
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.flink.table.planner.plan.nodes.exec.stream;
+
+import org.apache.flink.api.dag.Transformation;
+import org.apache.flink.streaming.api.operators.OneInputStreamOperator;
+import org.apache.flink.streaming.api.transformations.OneInputTransformation;
+import org.apache.flink.table.api.TableConfig;
+import org.apache.flink.table.data.RowData;
+import org.apache.flink.table.planner.codegen.CodeGeneratorContext;
+import org.apache.flink.table.planner.codegen.agg.AggsHandlerCodeGenerator;
+import org.apache.flink.table.planner.delegation.PlannerBase;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecEdge;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecNode;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeBase;
+import org.apache.flink.table.planner.plan.utils.AggregateInfoList;
+import org.apache.flink.table.planner.plan.utils.AggregateUtil;
+import org.apache.flink.table.planner.plan.utils.KeySelectorUtil;
+import org.apache.flink.table.planner.utils.JavaScalaConversionUtil;
+import org.apache.flink.table.runtime.generated.GeneratedAggsHandleFunction;
+import org.apache.flink.table.runtime.keyselector.RowDataKeySelector;
+import org.apache.flink.table.runtime.operators.aggregate.MiniBatchIncrementalGroupAggFunction;
+import org.apache.flink.table.runtime.operators.bundle.KeyedMapBundleOperator;
+import org.apache.flink.table.runtime.typeutils.InternalTypeInfo;
+import org.apache.flink.table.types.DataType;
+import org.apache.flink.table.types.logical.RowType;
+
+import org.apache.calcite.rel.core.AggregateCall;
+import org.apache.calcite.tools.RelBuilder;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+/** Stream {@link ExecNode} for unbounded incremental group aggregate. */
+public class StreamExecIncrementalGroupAggregate extends ExecNodeBase<RowData>
+        implements StreamExecNode<RowData> {
+
+    /** The partial agg's grouping. */
+    private final int[] partialAggGrouping;
+    /** The final agg's grouping. */
+    private final int[] finalAggGrouping;
+    /** The partial agg's original agg calls. */
+    private final AggregateCall[] partialOriginalAggCalls;
+    /** Each element indicates whether the corresponding agg call needs `retract` method. */
+    private final boolean[] partialAggCallNeedRetractions;
+    /** The input row type of this node's partial local agg. */
+    private final RowType partialLocalAggInputRowType;
+    /** Whether this node consumes retraction messages. */
+    private final boolean partialAggNeedRetraction;
+
+    public StreamExecIncrementalGroupAggregate(
+            int[] partialAggGrouping,
+            int[] finalAggGrouping,
+            AggregateCall[] partialOriginalAggCalls,
+            boolean[] partialAggCallNeedRetractions,
+            RowType partialLocalAggInputRowType,
+            boolean partialAggNeedRetraction,
+            ExecEdge inputEdge,
+            RowType outputType,
+            String description) {
+        super(Collections.singletonList(inputEdge), outputType, description);
+        this.partialAggGrouping = partialAggGrouping;
+        this.finalAggGrouping = finalAggGrouping;
+        this.partialOriginalAggCalls = partialOriginalAggCalls;
+        this.partialAggCallNeedRetractions = partialAggCallNeedRetractions;
+        this.partialLocalAggInputRowType = partialLocalAggInputRowType;
+        this.partialAggNeedRetraction = partialAggNeedRetraction;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected Transformation<RowData> translateToPlanInternal(PlannerBase planner) {
+        final TableConfig config = planner.getTableConfig();
+        final ExecNode<RowData> inputNode = (ExecNode<RowData>) getInputNodes().get(0);
+        final Transformation<RowData> inputTransform = inputNode.translateToPlan(planner);
+
+        final AggregateInfoList partialLocalAggInfoList =
+                AggregateUtil.createPartialAggInfoList(
+                        partialLocalAggInputRowType,
+                        JavaScalaConversionUtil.toScala(Arrays.asList(partialOriginalAggCalls)),
+                        partialAggCallNeedRetractions,
+                        partialAggNeedRetraction,
+                        false);
+
+        final GeneratedAggsHandleFunction partialAggsHandler =
+                generateAggsHandler(
+                        "PartialGroupAggsHandler",
+                        partialLocalAggInfoList,
+                        partialAggGrouping.length,
+                        partialLocalAggInfoList.getAccTypes(),
+                        config,
+                        planner.getRelBuilder(),
+                        // the partial aggregate accumulators will be buffered, so need copy
+                        true);
+
+        final AggregateInfoList incrementalAggInfo =
+                AggregateUtil.createIncrementalAggInfoList(
+                        partialLocalAggInputRowType,
+                        JavaScalaConversionUtil.toScala(Arrays.asList(partialOriginalAggCalls)),
+                        partialAggCallNeedRetractions,
+                        partialAggNeedRetraction);
+
+        final GeneratedAggsHandleFunction finalAggsHandler =
+                generateAggsHandler(
+                        "FinalGroupAggsHandler",
+                        incrementalAggInfo,
+                        0,
+                        partialLocalAggInfoList.getAccTypes(),
+                        config,
+                        planner.getRelBuilder(),
+                        // the final aggregate accumulators is not buffered
+                        false);
+
+        final RowDataKeySelector partialKeySelector =
+                KeySelectorUtil.getRowDataSelector(
+                        partialAggGrouping, InternalTypeInfo.of(inputNode.getOutputType()));
+        final RowDataKeySelector finalKeySelector =
+                KeySelectorUtil.getRowDataSelector(
+                        finalAggGrouping, partialKeySelector.getProducedType());
+
+        final MiniBatchIncrementalGroupAggFunction aggFunction =
+                new MiniBatchIncrementalGroupAggFunction(
+                        partialAggsHandler,
+                        finalAggsHandler,
+                        finalKeySelector,
+                        config.getIdleStateRetention().toMillis());
+
+        final OneInputStreamOperator<RowData, RowData> operator =
+                new KeyedMapBundleOperator<>(
+                        aggFunction, AggregateUtil.createMiniBatchTrigger(config));
+
+        // partitioned aggregation
+        final OneInputTransformation<RowData, RowData> transform =
+                new OneInputTransformation<>(
+                        inputTransform,
+                        getDesc(),
+                        operator,
+                        InternalTypeInfo.of(getOutputType()),
+                        inputTransform.getParallelism());
+
+        if (inputsContainSingleton()) {
+            transform.setParallelism(1);
+            transform.setMaxParallelism(1);
+        }
+
+        // set KeyType and Selector for state
+        transform.setStateKeySelector(partialKeySelector);
+        transform.setStateKeyType(partialKeySelector.getProducedType());
+        return transform;
+    }
+
+    private GeneratedAggsHandleFunction generateAggsHandler(
+            String name,
+            AggregateInfoList aggInfoList,
+            int mergedAccOffset,
+            DataType[] mergedAccExternalTypes,
+            TableConfig config,
+            RelBuilder relBuilder,
+            boolean inputFieldCopy) {
+
+        AggsHandlerCodeGenerator generator =
+                new AggsHandlerCodeGenerator(
+                        new CodeGeneratorContext(config),
+                        relBuilder,
+                        JavaScalaConversionUtil.toScala(partialLocalAggInputRowType.getChildren()),
+                        inputFieldCopy);
+
+        return generator
+                .needMerge(mergedAccOffset, true, mergedAccExternalTypes)
+                .generateAggsHandler(name, aggInfoList);
+    }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
index 5153643..10ec872 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
@@ -538,7 +538,7 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
       case agg: StreamPhysicalGroupAggregate => agg.grouping
       case agg: StreamPhysicalLocalGroupAggregate => agg.grouping
       case agg: StreamPhysicalGlobalGroupAggregate => agg.grouping
-      case agg: StreamExecIncrementalGroupAggregate => agg.partialAggGrouping
+      case agg: StreamPhysicalIncrementalGroupAggregate => agg.partialAggGrouping
       case agg: StreamExecGroupWindowAggregate => agg.getGrouping
       case agg: BatchExecGroupAggregateBase => agg.getGrouping ++ agg.getAuxGrouping
       case agg: Aggregate => AggregateUtil.checkAndGetFullGroupSet(agg)
@@ -608,9 +608,9 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
             }
           case agg: StreamPhysicalLocalGroupAggregate =>
             getAggCallFromLocalAgg(aggCallIndex, agg.aggCalls, agg.getInput.getRowType)
-          case agg: StreamExecIncrementalGroupAggregate
-            if agg.partialAggInfoList.getActualAggregateCalls.length > aggCallIndex =>
-            agg.partialAggInfoList.getActualAggregateCalls(aggCallIndex)
+          case agg: StreamPhysicalIncrementalGroupAggregate
+            if agg.partialAggCalls.length > aggCallIndex =>
+            agg.partialAggCalls(aggCallIndex)
           case agg: StreamExecGroupWindowAggregate if agg.aggCalls.length > aggCallIndex =>
             agg.aggCalls(aggCallIndex)
           case agg: BatchExecLocalHashAggregate =>
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
index 272b557..9b0932a 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
@@ -303,7 +303,7 @@ class FlinkRelMdModifiedMonotonicity private extends MetadataHandler[ModifiedMon
   }
 
   def getRelModifiedMonotonicity(
-      rel: StreamExecIncrementalGroupAggregate,
+      rel: StreamPhysicalIncrementalGroupAggregate,
       mq: RelMetadataQuery): RelModifiedMonotonicity = {
     getRelModifiedMonotonicityOnAggregate(
       rel.getInput, mq, rel.finalAggCalls.toList, rel.finalAggGrouping)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
deleted file mode 100644
index bcb6a93..0000000
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.flink.table.planner.plan.nodes.physical.stream
-
-import org.apache.flink.api.dag.Transformation
-import org.apache.flink.streaming.api.transformations.OneInputTransformation
-import org.apache.flink.table.api.TableConfig
-import org.apache.flink.table.data.RowData
-import org.apache.flink.table.planner.calcite.FlinkTypeFactory
-import org.apache.flink.table.planner.codegen.CodeGeneratorContext
-import org.apache.flink.table.planner.codegen.agg.AggsHandlerCodeGenerator
-import org.apache.flink.table.planner.delegation.StreamPlanner
-import org.apache.flink.table.planner.plan.nodes.exec.LegacyStreamExecNode
-import org.apache.flink.table.planner.plan.utils.{KeySelectorUtil, _}
-import org.apache.flink.table.runtime.generated.GeneratedAggsHandleFunction
-import org.apache.flink.table.runtime.operators.aggregate.MiniBatchIncrementalGroupAggFunction
-import org.apache.flink.table.runtime.operators.bundle.KeyedMapBundleOperator
-import org.apache.flink.table.runtime.typeutils.InternalTypeInfo
-import org.apache.flink.table.types.DataType
-
-import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
-import org.apache.calcite.rel.`type`.RelDataType
-import org.apache.calcite.rel.core.AggregateCall
-import org.apache.calcite.rel.{RelNode, RelWriter}
-import org.apache.calcite.tools.RelBuilder
-
-import java.util
-
-import scala.collection.JavaConversions._
-
-/**
-  * Stream physical RelNode for unbounded incremental group aggregate.
-  *
-  * <p>Considering the following sub-plan:
-  * {{{
-  *   StreamPhysicalGlobalGroupAggregate (final-global-aggregate)
-  *   +- StreamPhysicalExchange
-  *      +- StreamPhysicalLocalGroupAggregate (final-local-aggregate)
-  *         +- StreamPhysicalGlobalGroupAggregate (partial-global-aggregate)
-  *            +- StreamPhysicalExchange
-  *               +- StreamPhysicalLocalGroupAggregate (partial-local-aggregate)
-  * }}}
-  *
-  * partial-global-aggregate and final-local-aggregate can be combined as
-  * this node to share [[org.apache.flink.api.common.state.State]].
-  * now the sub-plan is
-  * {{{
-  *   StreamPhysicalGlobalGroupAggregate (final-global-aggregate)
-  *   +- StreamPhysicalExchange
-  *      +- StreamExecIncrementalGroupAggregate
-  *         +- StreamPhysicalExchange
-  *            +- StreamPhysicalLocalGroupAggregate (partial-local-aggregate)
-  * }}}
-  *
-  * @see [[StreamPhysicalGroupAggregateBase]] for more info.
-  */
-class StreamExecIncrementalGroupAggregate(
-    cluster: RelOptCluster,
-    traitSet: RelTraitSet,
-    inputRel: RelNode,
-    inputRowType: RelDataType,
-    outputRowType: RelDataType,
-    val partialAggInfoList: AggregateInfoList,
-    finalAggInfoList: AggregateInfoList,
-    val finalAggCalls: Seq[AggregateCall],
-    val finalAggGrouping: Array[Int],
-    val partialAggGrouping: Array[Int])
-  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel)
-  with LegacyStreamExecNode[RowData] {
-
-  override def deriveRowType(): RelDataType = outputRowType
-
-  override def requireWatermark: Boolean = false
-
-  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
-    new StreamExecIncrementalGroupAggregate(
-      cluster,
-      traitSet,
-      inputs.get(0),
-      inputRowType,
-      outputRowType,
-      partialAggInfoList,
-      finalAggInfoList,
-      finalAggCalls,
-      finalAggGrouping,
-      partialAggGrouping)
-  }
-
-  override def explainTerms(pw: RelWriter): RelWriter = {
-    super.explainTerms(pw)
-      .item("partialAggGrouping",
-        RelExplainUtil.fieldToString(partialAggGrouping, inputRel.getRowType))
-      .item("finalAggGrouping",
-    RelExplainUtil.fieldToString(finalAggGrouping, inputRel.getRowType))
-      .item("select", RelExplainUtil.streamGroupAggregationToString(
-        inputRel.getRowType,
-        getRowType,
-        finalAggInfoList,
-        finalAggGrouping,
-        shuffleKey = Some(partialAggGrouping)))
-  }
-
-  //~ ExecNode methods -----------------------------------------------------------
-
-  override protected def translateToPlanInternal(
-      planner: StreamPlanner): Transformation[RowData] = {
-    val config = planner.getTableConfig
-    val inputTransformation = getInputNodes.get(0).translateToPlan(planner)
-      .asInstanceOf[Transformation[RowData]]
-
-    val inRowType = FlinkTypeFactory.toLogicalRowType(inputRel.getRowType)
-    val outRowType = FlinkTypeFactory.toLogicalRowType(outputRowType)
-
-    val partialAggsHandler = generateAggsHandler(
-      "PartialGroupAggsHandler",
-      partialAggInfoList,
-      mergedAccOffset = partialAggGrouping.length,
-      partialAggInfoList.getAccTypes,
-      config,
-      planner.getRelBuilder,
-      // the partial aggregate accumulators will be buffered, so need copy
-      inputFieldCopy = true)
-
-    val finalAggsHandler = generateAggsHandler(
-      "FinalGroupAggsHandler",
-      finalAggInfoList,
-      mergedAccOffset = 0,
-      partialAggInfoList.getAccTypes,
-      config,
-      planner.getRelBuilder,
-      // the final aggregate accumulators is not buffered
-      inputFieldCopy = false)
-
-    val partialKeySelector = KeySelectorUtil.getRowDataSelector(
-      partialAggGrouping,
-      InternalTypeInfo.of(inRowType))
-    val finalKeySelector = KeySelectorUtil.getRowDataSelector(
-      finalAggGrouping,
-      partialKeySelector.getProducedType)
-
-    val aggFunction = new MiniBatchIncrementalGroupAggFunction(
-      partialAggsHandler,
-      finalAggsHandler,
-      finalKeySelector,
-      config.getIdleStateRetention.toMillis)
-
-    val operator = new KeyedMapBundleOperator(
-      aggFunction,
-      AggregateUtil.createMiniBatchTrigger(config))
-
-    // partitioned aggregation
-    val ret = new OneInputTransformation(
-      inputTransformation,
-      getRelDetailedDescription,
-      operator,
-      InternalTypeInfo.of(outRowType),
-      inputTransformation.getParallelism)
-
-    if (inputsContainSingleton()) {
-      ret.setParallelism(1)
-      ret.setMaxParallelism(1)
-    }
-
-    // set KeyType and Selector for state
-    ret.setStateKeySelector(partialKeySelector)
-    ret.setStateKeyType(partialKeySelector.getProducedType)
-    ret
-  }
-
-  def generateAggsHandler(
-    name: String,
-    aggInfoList: AggregateInfoList,
-    mergedAccOffset: Int,
-    mergedAccExternalTypes: Array[DataType],
-    config: TableConfig,
-    relBuilder: RelBuilder,
-    inputFieldCopy: Boolean): GeneratedAggsHandleFunction = {
-
-    val generator = new AggsHandlerCodeGenerator(
-      CodeGeneratorContext(config),
-      relBuilder,
-      FlinkTypeFactory.toLogicalRowType(inputRowType).getChildren,
-      inputFieldCopy)
-
-    generator
-      .needAccumulate()
-      .needMerge(mergedAccOffset, mergedAccOnHeap = true, mergedAccExternalTypes)
-      .generateAggsHandler(name, aggInfoList)
-  }
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGlobalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGlobalGroupAggregate.scala
index b4e0e2e..7cec0fc 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGlobalGroupAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGlobalGroupAggregate.scala
@@ -40,9 +40,9 @@ class StreamPhysicalGlobalGroupAggregate(
     outputRowType: RelDataType,
     val grouping: Array[Int],
     val aggCalls: Seq[AggregateCall],
-    aggCallNeedRetractions: Array[Boolean],
+    val aggCallNeedRetractions: Array[Boolean],
     val localAggInputRowType: RelDataType,
-    needRetraction: Boolean,
+    val needRetraction: Boolean,
     val partialFinalType: PartialFinalType)
   extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel) {
 
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalIncrementalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalIncrementalGroupAggregate.scala
new file mode 100644
index 0000000..cb203b7
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalIncrementalGroupAggregate.scala
@@ -0,0 +1,132 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.flink.table.planner.plan.nodes.physical.stream
+
+import org.apache.flink.table.planner.calcite.FlinkTypeFactory
+import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecIncrementalGroupAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.{ExecEdge, ExecNode}
+import org.apache.flink.table.planner.plan.utils._
+
+import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
+import org.apache.calcite.rel.`type`.RelDataType
+import org.apache.calcite.rel.core.AggregateCall
+import org.apache.calcite.rel.{RelNode, RelWriter}
+
+import java.util
+
+/**
+ * Stream physical RelNode for unbounded incremental group aggregate.
+ *
+ * <p>Considering the following sub-plan:
+ * {{{
+ *   StreamPhysicalGlobalGroupAggregate (final-global-aggregate)
+ *   +- StreamPhysicalExchange
+ *      +- StreamPhysicalLocalGroupAggregate (final-local-aggregate)
+ *         +- StreamPhysicalGlobalGroupAggregate (partial-global-aggregate)
+ *            +- StreamPhysicalExchange
+ *               +- StreamPhysicalLocalGroupAggregate (partial-local-aggregate)
+ * }}}
+ *
+ * partial-global-aggregate and final-local-aggregate can be combined as
+ * this node to share [[org.apache.flink.api.common.state.State]].
+ * now the sub-plan is
+ * {{{
+ *   StreamPhysicalGlobalGroupAggregate (final-global-aggregate)
+ *   +- StreamPhysicalExchange
+ *      +- StreamPhysicalIncrementalGroupAggregate
+ *         +- StreamPhysicalExchange
+ *            +- StreamPhysicalLocalGroupAggregate (partial-local-aggregate)
+ * }}}
+ *
+ * @see [[StreamPhysicalGroupAggregateBase]] for more info.
+ */
+class StreamPhysicalIncrementalGroupAggregate(
+    cluster: RelOptCluster,
+    traitSet: RelTraitSet,
+    inputRel: RelNode,
+    val partialAggGrouping: Array[Int],
+    val partialAggCalls: Array[AggregateCall],
+    val finalAggGrouping: Array[Int],
+    val finalAggCalls: Array[AggregateCall],
+    partialOriginalAggCalls: Array[AggregateCall],
+    partialAggCallNeedRetractions: Array[Boolean],
+    partialAggNeedRetraction: Boolean,
+    partialLocalAggInputRowType: RelDataType,
+    partialGlobalAggRowType: RelDataType)
+  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel) {
+
+  private lazy val incrementalAggInfo = AggregateUtil.createIncrementalAggInfoList(
+    FlinkTypeFactory.toLogicalRowType(partialLocalAggInputRowType),
+    partialOriginalAggCalls,
+    partialAggCallNeedRetractions,
+    partialAggNeedRetraction)
+
+  override def deriveRowType(): RelDataType = {
+    AggregateUtil.inferLocalAggRowType(
+      incrementalAggInfo,
+      partialGlobalAggRowType,
+      finalAggGrouping,
+      getCluster.getTypeFactory.asInstanceOf[FlinkTypeFactory])
+  }
+
+  override def requireWatermark: Boolean = false
+
+  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
+    new StreamPhysicalIncrementalGroupAggregate(
+      cluster,
+      traitSet,
+      inputs.get(0),
+      partialAggGrouping,
+      partialAggCalls,
+      finalAggGrouping,
+      finalAggCalls,
+      partialOriginalAggCalls,
+      partialAggCallNeedRetractions,
+      partialAggNeedRetraction,
+      partialLocalAggInputRowType,
+      partialGlobalAggRowType)
+  }
+
+  override def explainTerms(pw: RelWriter): RelWriter = {
+    super.explainTerms(pw)
+      .item("partialAggGrouping",
+        RelExplainUtil.fieldToString(partialAggGrouping, inputRel.getRowType))
+      .item("finalAggGrouping",
+        RelExplainUtil.fieldToString(finalAggGrouping, inputRel.getRowType))
+      .item("select", RelExplainUtil.streamGroupAggregationToString(
+        inputRel.getRowType,
+        getRowType,
+        incrementalAggInfo,
+        finalAggGrouping,
+        shuffleKey = Some(partialAggGrouping)))
+  }
+
+  override def translateToExecNode(): ExecNode[_] = {
+    new StreamExecIncrementalGroupAggregate(
+      partialAggGrouping,
+      finalAggGrouping,
+      partialOriginalAggCalls,
+      partialAggCallNeedRetractions,
+      FlinkTypeFactory.toLogicalRowType(partialLocalAggInputRowType),
+      partialAggNeedRetraction,
+      ExecEdge.DEFAULT,
+      FlinkTypeFactory.toLogicalRowType(getRowType),
+      getRelDetailedDescription
+    )
+  }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
index ee8f074..235c441 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
@@ -22,8 +22,8 @@ import org.apache.flink.configuration.ConfigOption
 import org.apache.flink.configuration.ConfigOptions.key
 import org.apache.flink.table.planner.calcite.{FlinkContext, FlinkTypeFactory}
 import org.apache.flink.table.planner.plan.PartialFinalType
-import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecIncrementalGroupAggregate, StreamPhysicalExchange, StreamPhysicalGlobalGroupAggregate, StreamPhysicalLocalGroupAggregate}
-import org.apache.flink.table.planner.plan.utils.{AggregateInfoList, AggregateUtil, DistinctInfo}
+import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamPhysicalExchange, StreamPhysicalGlobalGroupAggregate, StreamPhysicalIncrementalGroupAggregate, StreamPhysicalLocalGroupAggregate}
+import org.apache.flink.table.planner.plan.utils.AggregateUtil
 import org.apache.flink.util.Preconditions
 
 import org.apache.calcite.plan.RelOptRule.{any, operand}
@@ -37,7 +37,7 @@ import java.util.Collections
  * on final [[StreamPhysicalLocalGroupAggregate]] on partial [[StreamPhysicalGlobalGroupAggregate]],
  * and combines the final [[StreamPhysicalLocalGroupAggregate]] and
  * the partial [[StreamPhysicalGlobalGroupAggregate]] into a
- * [[StreamExecIncrementalGroupAggregate]].
+ * [[StreamPhysicalIncrementalGroupAggregate]].
  */
 class IncrementalAggregateRule
   extends RelOptRule(
@@ -69,55 +69,26 @@ class IncrementalAggregateRule
     val exchange: StreamPhysicalExchange = call.rel(1)
     val finalLocalAgg: StreamPhysicalLocalGroupAggregate = call.rel(2)
     val partialGlobalAgg: StreamPhysicalGlobalGroupAggregate = call.rel(3)
-    val aggInputRowType = partialGlobalAgg.localAggInputRowType
-
-    val partialLocalAggInfoList = partialGlobalAgg.localAggInfoList
-    val partialGlobalAggInfoList = partialGlobalAgg.globalAggInfoList
-    val finalGlobalAggInfoList = finalGlobalAgg.globalAggInfoList
-    val aggCalls = finalGlobalAggInfoList.getActualAggregateCalls
-
-    val typeFactory = finalGlobalAgg.getCluster.getTypeFactory.asInstanceOf[FlinkTypeFactory]
-
-    // pick distinct info from global which is on state, and modify excludeAcc parameter
-    val incrDistinctInfo = partialGlobalAggInfoList.distinctInfos.map { info =>
-      DistinctInfo(
-        info.argIndexes,
-        info.keyType,
-        info.accType,
-        // exclude distinct acc from the aggregate accumulator,
-        // because the output acc only need to contain the count
-        excludeAcc = true,
-        info.dataViewSpec,
-        info.consumeRetraction,
-        info.filterArgs,
-        info.aggIndexes
-      )
-    }
-
-    val incrAggInfoList = AggregateInfoList(
-      // pick local aggs info from local which is on heap
-      partialLocalAggInfoList.aggInfos,
-      partialGlobalAggInfoList.indexOfCountStar,
-      partialGlobalAggInfoList.countStarInserted,
-      incrDistinctInfo)
+    val partialLocalAggInputRowType = partialGlobalAgg.localAggInputRowType
 
-    val incrAggOutputRowType = AggregateUtil.inferLocalAggRowType(
-      incrAggInfoList,
-      partialGlobalAgg.getRowType,
-      finalGlobalAgg.grouping,
-      typeFactory)
+    val partialOriginalAggCalls = partialGlobalAgg.aggCalls.toArray
+    val partialRealAggCalls = partialGlobalAgg.localAggInfoList.getActualAggregateCalls
+    val finalRealAggCalls = finalGlobalAgg.globalAggInfoList.getActualAggregateCalls
 
-    val incrAgg = new StreamExecIncrementalGroupAggregate(
+    val incrAgg = new StreamPhysicalIncrementalGroupAggregate(
       partialGlobalAgg.getCluster,
       finalLocalAgg.getTraitSet, // extends final local agg traits (ACC trait)
       partialGlobalAgg.getInput,
-      aggInputRowType,
-      incrAggOutputRowType,
-      partialLocalAggInfoList,
-      incrAggInfoList,
-      aggCalls,
+      partialGlobalAgg.grouping,
+      partialRealAggCalls,
       finalLocalAgg.grouping,
-      partialGlobalAgg.grouping)
+      finalRealAggCalls,
+      partialOriginalAggCalls,
+      partialGlobalAgg.aggCallNeedRetractions,
+      partialGlobalAgg.needRetraction,
+      partialLocalAggInputRowType,
+      partialGlobalAgg.getRowType)
+    val incrAggOutputRowType = incrAgg.getRowType
 
     val newExchange = exchange.copy(exchange.getTraitSet, incrAgg, exchange.distribution)
 
@@ -135,9 +106,9 @@ class IncrementalAggregateRule
       val localAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
         // the final agg input is partial agg
         FlinkTypeFactory.toLogicalRowType(partialGlobalAgg.getRowType),
-        aggCalls,
+        finalRealAggCalls,
         // all the aggs do not need retraction
-        Array.fill(aggCalls.length)(false),
+        Array.fill(finalRealAggCalls.length)(false),
         // also do not need count*
         needInputCount = false,
         // the local agg is not works on state
@@ -148,7 +119,7 @@ class IncrementalAggregateRule
         localAggInfoList,
         incrAgg.getRowType,
         finalGlobalAgg.grouping,
-        typeFactory)
+        finalGlobalAgg.getCluster.getTypeFactory.asInstanceOf[FlinkTypeFactory])
 
       Preconditions.checkState(RelOptUtil.areRowTypesEqual(
         incrAggOutputRowType,
@@ -161,9 +132,9 @@ class IncrementalAggregateRule
         newExchange,
         finalGlobalAgg.getRowType,
         finalGlobalAgg.grouping,
-        aggCalls,
+        finalRealAggCalls,
         // all the aggs do not need retraction
-        Array.fill(aggCalls.length)(false),
+        Array.fill(finalRealAggCalls.length)(false),
         finalGlobalAgg.localAggInputRowType,
         needRetraction = false,
         finalGlobalAgg.partialFinalType)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala
index ea1205b..43f3e3e 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala
@@ -175,6 +175,62 @@ object AggregateUtil extends Enumeration {
     map
   }
 
+  def createPartialAggInfoList(
+      partialLocalAggInputRowType: RowType,
+      partialOriginalAggCalls: Seq[AggregateCall],
+      partialAggCallNeedRetractions: Array[Boolean],
+      partialAggNeedRetraction: Boolean,
+      isGlobal: Boolean): AggregateInfoList = {
+    transformToStreamAggregateInfoList(
+      partialLocalAggInputRowType,
+      partialOriginalAggCalls,
+      partialAggCallNeedRetractions,
+      partialAggNeedRetraction,
+      isStateBackendDataViews = isGlobal)
+  }
+
+  def createIncrementalAggInfoList(
+      partialLocalAggInputRowType: RowType,
+      partialOriginalAggCalls: Seq[AggregateCall],
+      partialAggCallNeedRetractions: Array[Boolean],
+      partialAggNeedRetraction: Boolean): AggregateInfoList = {
+    val partialLocalAggInfoList = createPartialAggInfoList(
+      partialLocalAggInputRowType,
+      partialOriginalAggCalls,
+      partialAggCallNeedRetractions,
+      partialAggNeedRetraction,
+      isGlobal = false)
+    val partialGlobalAggInfoList = createPartialAggInfoList(
+      partialLocalAggInputRowType,
+      partialOriginalAggCalls,
+      partialAggCallNeedRetractions,
+      partialAggNeedRetraction,
+      isGlobal = true)
+
+    // pick distinct info from global which is on state, and modify excludeAcc parameter
+    val incrementalDistinctInfos = partialGlobalAggInfoList.distinctInfos.map { info =>
+      DistinctInfo(
+        info.argIndexes,
+        info.keyType,
+        info.accType,
+        // exclude distinct acc from the aggregate accumulator,
+        // because the output acc only need to contain the count
+        excludeAcc = true,
+        info.dataViewSpec,
+        info.consumeRetraction,
+        info.filterArgs,
+        info.aggIndexes
+      )
+    }
+
+    AggregateInfoList(
+      // pick local aggs info from local which is on heap
+      partialLocalAggInfoList.aggInfos,
+      partialGlobalAggInfoList.indexOfCountStar,
+      partialGlobalAggInfoList.countStarInserted,
+      incrementalDistinctInfos)
+  }
+
   def deriveAggregateInfoList(
       agg: StreamPhysicalRel,
       groupCount: Int,
@@ -532,6 +588,7 @@ object AggregateUtil extends Enumeration {
   /**
     * Inserts an COUNT(*) aggregate call if needed. The COUNT(*) aggregate call is used
     * to count the number of added and retracted input records.
+    *
     * @param needInputCount whether to insert an InputCount aggregate
     * @param aggregateCalls original aggregate calls
     * @return (indexOfCountStar, countStarInserted, newAggCalls)
@@ -885,7 +942,7 @@ object AggregateUtil extends Enumeration {
   def createMiniBatchTrigger(tableConfig: TableConfig): CountBundleTrigger[RowData] = {
     val size = tableConfig.getConfiguration.getLong(
       ExecutionConfigOptions.TABLE_EXEC_MINIBATCH_SIZE)
-    if (size <= 0 ) {
+    if (size <= 0) {
       throw new IllegalArgumentException(
         ExecutionConfigOptions.TABLE_EXEC_MINIBATCH_SIZE + " must be > 0.")
     }

[flink] 01/08: [FLINK-20737][table-planner-blink] Use RowType instead of RelDataType when building aggregate info

Posted by go...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 53a888c52499fdd452e41f5e21dc7b4a9630e4f5
Author: godfreyhe <go...@163.com>
AuthorDate: Thu Dec 24 18:12:47 2020 +0800

    [FLINK-20737][table-planner-blink] Use RowType instead of RelDataType when building aggregate info
    
    This closes #14478
---
 .../batch/BatchExecPythonAggregateRule.java        |   5 +-
 .../batch/BatchExecPythonWindowAggregateRule.java  |   5 +-
 .../table/planner/codegen/MatchCodeGenerator.scala |   2 +-
 .../batch/BatchExecHashAggregateBase.scala         |   2 +-
 .../batch/BatchExecHashWindowAggregateBase.scala   |   2 +-
 .../physical/batch/BatchExecOverAggregate.scala    |  18 ++--
 .../batch/BatchExecSortAggregateBase.scala         |   2 +-
 .../batch/BatchExecSortWindowAggregateBase.scala   |   2 +-
 .../physical/stream/StreamExecGroupAggregate.scala |   4 +-
 .../stream/StreamExecGroupTableAggregateBase.scala |   4 +-
 .../StreamExecGroupWindowAggregateBase.scala       |   2 +-
 .../physical/stream/StreamExecOverAggregate.scala  |   8 +-
 .../stream/StreamExecPythonGroupAggregate.scala    |   4 +-
 .../physical/batch/BatchExecAggRuleBase.scala      |   2 +-
 .../physical/batch/BatchExecHashAggRule.scala      |   4 +-
 .../batch/BatchExecOverAggregateRule.scala         |   4 +-
 .../physical/batch/BatchExecSortAggRule.scala      |   4 +-
 .../batch/BatchExecWindowAggregateRule.scala       |   2 +-
 .../physical/batch/EnforceLocalAggRuleBase.scala   |   5 +-
 .../physical/stream/IncrementalAggregateRule.scala |   8 +-
 .../stream/TwoStageOptimizedAggregateRule.scala    |  10 +-
 .../planner/plan/utils/AggFunctionFactory.scala    |  46 ++++-----
 .../table/planner/plan/utils/AggregateUtil.scala   | 105 ++++++++++-----------
 .../plan/metadata/FlinkRelMdHandlerTestBase.scala  |  27 ++++--
 24 files changed, 140 insertions(+), 137 deletions(-)

diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecPythonAggregateRule.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecPythonAggregateRule.java
index 9b69cc2..f1c2ab5 100644
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecPythonAggregateRule.java
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecPythonAggregateRule.java
@@ -21,6 +21,7 @@ package org.apache.flink.table.planner.plan.rules.physical.batch;
 import org.apache.flink.table.api.TableException;
 import org.apache.flink.table.functions.UserDefinedFunction;
 import org.apache.flink.table.functions.python.PythonFunctionKind;
+import org.apache.flink.table.planner.calcite.FlinkTypeFactory;
 import org.apache.flink.table.planner.plan.nodes.FlinkConventions;
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalAggregate;
 import org.apache.flink.table.planner.plan.nodes.physical.batch.BatchExecPythonGroupAggregate;
@@ -106,7 +107,9 @@ public class BatchExecPythonAggregateRule extends ConverterRule {
 
         Tuple3<int[][], DataType[][], UserDefinedFunction[]> aggBufferTypesAndFunctions =
                 AggregateUtil.transformToBatchAggregateFunctions(
-                        aggCallsWithoutAuxGroupCalls, input.getRowType(), null);
+                        FlinkTypeFactory.toLogicalRowType(input.getRowType()),
+                        aggCallsWithoutAuxGroupCalls,
+                        null);
         UserDefinedFunction[] aggFunctions = aggBufferTypesAndFunctions._3();
 
         RelTraitSet requiredTraitSet =
diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecPythonWindowAggregateRule.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecPythonWindowAggregateRule.java
index 154dc07..958188d 100644
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecPythonWindowAggregateRule.java
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecPythonWindowAggregateRule.java
@@ -22,6 +22,7 @@ import org.apache.flink.table.api.TableException;
 import org.apache.flink.table.functions.UserDefinedFunction;
 import org.apache.flink.table.functions.python.PythonFunctionKind;
 import org.apache.flink.table.planner.calcite.FlinkRelFactories;
+import org.apache.flink.table.planner.calcite.FlinkTypeFactory;
 import org.apache.flink.table.planner.plan.logical.LogicalWindow;
 import org.apache.flink.table.planner.plan.logical.SessionGroupWindow;
 import org.apache.flink.table.planner.plan.logical.SlidingGroupWindow;
@@ -121,7 +122,9 @@ public class BatchExecPythonWindowAggregateRule extends RelOptRule {
 
         Tuple3<int[][], DataType[][], UserDefinedFunction[]> aggBufferTypesAndFunctions =
                 AggregateUtil.transformToBatchAggregateFunctions(
-                        aggCallsWithoutAuxGroupCalls, input.getRowType(), null);
+                        FlinkTypeFactory.toLogicalRowType(input.getRowType()),
+                        aggCallsWithoutAuxGroupCalls,
+                        null);
         UserDefinedFunction[] aggFunctions = aggBufferTypesAndFunctions._3();
 
         int inputTimeFieldIndex =
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/codegen/MatchCodeGenerator.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/codegen/MatchCodeGenerator.scala
index b4f83fd..4297a29 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/codegen/MatchCodeGenerator.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/codegen/MatchCodeGenerator.scala
@@ -682,8 +682,8 @@ class MatchCodeGenerator(
         matchAgg.inputExprs.indices.map(i => s"TMP$i"))
 
       val aggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
+        FlinkTypeFactory.toLogicalRowType(inputRelType),
         aggCalls,
-        inputRelType,
         needRetraction,
         needInputCount = false,
         isStateBackendDataViews = false,
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecHashAggregateBase.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecHashAggregateBase.scala
index 10b1ed7..9400dbd 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecHashAggregateBase.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecHashAggregateBase.scala
@@ -114,7 +114,7 @@ abstract class BatchExecHashAggregateBase(
     val inputType = FlinkTypeFactory.toLogicalRowType(inputRowType)
 
     val aggInfos = transformToBatchAggregateInfoList(
-      aggCallToAggFunction.map(_._1), aggInputRowType)
+      FlinkTypeFactory.toLogicalRowType(aggInputRowType), aggCallToAggFunction.map(_._1))
 
     var managedMemory: Long = 0L
     val generatedOperator = if (grouping.isEmpty) {
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecHashWindowAggregateBase.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecHashWindowAggregateBase.scala
index 595c0b8..c7e1f12 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecHashWindowAggregateBase.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecHashWindowAggregateBase.scala
@@ -113,7 +113,7 @@ abstract class BatchExecHashWindowAggregateBase(
     val inputType = FlinkTypeFactory.toLogicalRowType(inputRowType)
 
     val aggInfos = transformToBatchAggregateInfoList(
-      aggCallToAggFunction.map(_._1), aggInputRowType)
+      FlinkTypeFactory.toLogicalRowType(aggInputRowType), aggCallToAggFunction.map(_._1))
 
     val groupBufferLimitSize = config.getConfiguration.getInteger(
       ExecutionConfigOptions.TABLE_EXEC_WINDOW_AGG_BUFFER_SIZE_LIMIT)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecOverAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecOverAggregate.scala
index 82329f5..04e1c3f 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecOverAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecOverAggregate.scala
@@ -140,10 +140,10 @@ class BatchExecOverAggregate(
       //operator needn't cache data
       val aggHandlers = modeToGroupToAggCallToAggFunction.map { case (_, _, aggCallToAggFunction) =>
         val aggInfoList = transformToBatchAggregateInfoList(
-          aggCallToAggFunction.map(_._1),
           // use aggInputType which considers constants as input instead of inputType
-          inputTypeWithConstants,
-          orderKeyIndices)
+          FlinkTypeFactory.toLogicalRowType(inputTypeWithConstants),
+          aggCallToAggFunction.map(_._1),
+          orderKeyIndexes = orderKeyIndices)
         val codeGenCtx = CodeGeneratorContext(config)
         val generator = new AggsHandlerCodeGenerator(
           codeGenCtx,
@@ -191,10 +191,10 @@ class BatchExecOverAggregate(
           //lies on the offset of the window frame.
           aggCallToAggFunction.map { case (aggCall, _) =>
             val aggInfoList = transformToBatchAggregateInfoList(
+              FlinkTypeFactory.toLogicalRowType(inputTypeWithConstants),
               Seq(aggCall),
-              inputTypeWithConstants,
-              orderKeyIndices,
-              Array[Boolean](true) /* needRetraction = true, See LeadLagAggFunction */)
+              Array[Boolean](true), /* needRetraction = true, See LeadLagAggFunction */
+              orderKeyIndexes = orderKeyIndices)
 
             val generator = new AggsHandlerCodeGenerator(
               CodeGeneratorContext(config),
@@ -263,10 +263,10 @@ class BatchExecOverAggregate(
 
         case _ =>
           val aggInfoList = transformToBatchAggregateInfoList(
-            aggCallToAggFunction.map(_._1),
             //use aggInputType which considers constants as input instead of inputSchema.relDataType
-            inputTypeWithConstants,
-            orderKeyIndices)
+            FlinkTypeFactory.toLogicalRowType(inputTypeWithConstants),
+            aggCallToAggFunction.map(_._1),
+            orderKeyIndexes = orderKeyIndices)
           val codeGenCtx = CodeGeneratorContext(config)
           val generator = new AggsHandlerCodeGenerator(
             codeGenCtx,
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecSortAggregateBase.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecSortAggregateBase.scala
index bf2dec4..12a617f 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecSortAggregateBase.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecSortAggregateBase.scala
@@ -95,7 +95,7 @@ abstract class BatchExecSortAggregateBase(
     val inputType = FlinkTypeFactory.toLogicalRowType(inputRowType)
 
     val aggInfos = transformToBatchAggregateInfoList(
-      aggCallToAggFunction.map(_._1), aggInputRowType)
+      FlinkTypeFactory.toLogicalRowType(aggInputRowType), aggCallToAggFunction.map(_._1))
 
     val generatedOperator = if (grouping.isEmpty) {
       AggWithoutKeysCodeGenerator.genWithoutKeys(
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecSortWindowAggregateBase.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecSortWindowAggregateBase.scala
index f919309..64c1b0e 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecSortWindowAggregateBase.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/batch/BatchExecSortWindowAggregateBase.scala
@@ -101,7 +101,7 @@ abstract class BatchExecSortWindowAggregateBase(
     val inputType = FlinkTypeFactory.toLogicalRowType(inputRowType)
 
     val aggInfos = transformToBatchAggregateInfoList(
-      aggCallToAggFunction.map(_._1), aggInputRowType)
+      FlinkTypeFactory.toLogicalRowType(aggInputRowType), aggCallToAggFunction.map(_._1))
 
     val groupBufferLimitSize = planner.getTableConfig.getConfiguration.getInteger(
       ExecutionConfigOptions.TABLE_EXEC_WINDOW_AGG_BUFFER_SIZE_LIMIT)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupAggregate.scala
index 210ee48..f7ae1d2 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupAggregate.scala
@@ -63,8 +63,8 @@ class StreamExecGroupAggregate(
 
   val aggInfoList: AggregateInfoList = AggregateUtil.deriveAggregateInfoList(
     this,
-    aggCalls,
-    grouping)
+    grouping.length,
+    aggCalls)
 
   override def requireWatermark: Boolean = false
 
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupTableAggregateBase.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupTableAggregateBase.scala
index 4c02b7d..c7c8a9b 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupTableAggregateBase.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupTableAggregateBase.scala
@@ -42,8 +42,8 @@ abstract class StreamExecGroupTableAggregateBase(
 
   val aggInfoList: AggregateInfoList = AggregateUtil.deriveAggregateInfoList(
     this,
-    aggCalls,
-    grouping)
+    grouping.length,
+    aggCalls)
 
   override def requireWatermark: Boolean = false
 
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupWindowAggregateBase.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupWindowAggregateBase.scala
index b8c0aa2..47b7b08 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupWindowAggregateBase.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupWindowAggregateBase.scala
@@ -137,8 +137,8 @@ abstract class StreamExecGroupWindowAggregateBase(
 
     val needRetraction = !ChangelogPlanUtils.inputInsertOnly(this)
     val aggInfoList = transformToStreamAggregateInfoList(
+      FlinkTypeFactory.toLogicalRowType(inputRowType),
       aggCalls,
-      inputRowType,
       Array.fill(aggCalls.size)(needRetraction),
       needInputCount = needRetraction,
       isStateBackendDataViews = true)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecOverAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecOverAggregate.scala
index fecd78e..494225f 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecOverAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecOverAggregate.scala
@@ -243,9 +243,9 @@ class StreamExecOverAggregate(
 
     val needRetraction = false
     val aggInfoList = transformToStreamAggregateInfoList(
-      aggregateCalls,
       // use aggInputType which considers constants as input instead of inputSchema.relDataType
-      aggInputType,
+      FlinkTypeFactory.toLogicalRowType(aggInputType),
+      aggregateCalls,
       Array.fill(aggregateCalls.size)(needRetraction),
       needInputCount = needRetraction,
       isStateBackendDataViews = true)
@@ -322,9 +322,9 @@ class StreamExecOverAggregate(
 
     val needRetraction = true
     val aggInfoList = transformToStreamAggregateInfoList(
-      aggregateCalls,
       // use aggInputType which considers constants as input instead of inputSchema.relDataType
-      aggInputType,
+      FlinkTypeFactory.toLogicalRowType(aggInputType),
+      aggregateCalls,
       Array.fill(aggregateCalls.size)(needRetraction),
       needInputCount = needRetraction,
       isStateBackendDataViews = true)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupAggregate.scala
index 4618183..aabf675 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupAggregate.scala
@@ -59,8 +59,8 @@ class StreamExecPythonGroupAggregate(
 
   val aggInfoList: AggregateInfoList = AggregateUtil.deriveAggregateInfoList(
     this,
-    aggCalls,
-    grouping)
+    grouping.length,
+    aggCalls)
 
   override def requireWatermark: Boolean = false
 
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecAggRuleBase.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecAggRuleBase.scala
index 49747b4..7d3a190 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecAggRuleBase.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecAggRuleBase.scala
@@ -154,7 +154,7 @@ trait BatchExecAggRuleBase {
   protected def isAggBufferFixedLength(agg: Aggregate): Boolean = {
     val (_, aggCallsWithoutAuxGroupCalls) = AggregateUtil.checkAndSplitAggCalls(agg)
     val (_, aggBufferTypes, _) = AggregateUtil.transformToBatchAggregateFunctions(
-      aggCallsWithoutAuxGroupCalls, agg.getInput.getRowType)
+      FlinkTypeFactory.toLogicalRowType(agg.getInput.getRowType), aggCallsWithoutAuxGroupCalls)
 
     isAggBufferFixedLength(aggBufferTypes.map(_.map(fromDataTypeToLogicalType)))
   }
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecHashAggRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecHashAggRule.scala
index 76b3ef5..1a28774 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecHashAggRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecHashAggRule.scala
@@ -18,7 +18,7 @@
 package org.apache.flink.table.planner.plan.rules.physical.batch
 
 import org.apache.flink.table.api.config.OptimizerConfigOptions
-import org.apache.flink.table.planner.calcite.FlinkContext
+import org.apache.flink.table.planner.calcite.{FlinkContext, FlinkTypeFactory}
 import org.apache.flink.table.planner.plan.`trait`.FlinkRelDistribution
 import org.apache.flink.table.planner.plan.nodes.FlinkConventions
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalAggregate
@@ -87,7 +87,7 @@ class BatchExecHashAggRule
     val (auxGroupSet, aggCallsWithoutAuxGroupCalls) = AggregateUtil.checkAndSplitAggCalls(agg)
 
     val (_, aggBufferTypes, aggFunctions) = AggregateUtil.transformToBatchAggregateFunctions(
-      aggCallsWithoutAuxGroupCalls, inputRowType)
+      FlinkTypeFactory.toLogicalRowType(inputRowType), aggCallsWithoutAuxGroupCalls)
 
     val aggCallToAggFunction = aggCallsWithoutAuxGroupCalls.zip(aggFunctions)
     val aggProvidedTraitSet = agg.getTraitSet.replace(FlinkConventions.BATCH_PHYSICAL)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecOverAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecOverAggregateRule.scala
index 58d1c45..091dbb2 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecOverAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecOverAggregateRule.scala
@@ -94,7 +94,9 @@ class BatchExecOverAggregateRule
       val groupToAggCallToAggFunction = groupBuffer.map { group =>
         val aggregateCalls = group.getAggregateCalls(logicWindow)
         val (_, _, aggregates) = AggregateUtil.transformToBatchAggregateFunctions(
-          aggregateCalls, inputTypeWithConstants, orderKeyIndexes)
+          FlinkTypeFactory.toLogicalRowType(inputTypeWithConstants),
+          aggregateCalls,
+          orderKeyIndexes)
         val aggCallToAggFunction = aggregateCalls.zip(aggregates)
         (group, aggCallToAggFunction)
       }
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecSortAggRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecSortAggRule.scala
index c164228..7bf6d16 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecSortAggRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecSortAggRule.scala
@@ -18,7 +18,7 @@
 package org.apache.flink.table.planner.plan.rules.physical.batch
 
 import org.apache.flink.table.api.config.OptimizerConfigOptions
-import org.apache.flink.table.planner.calcite.FlinkContext
+import org.apache.flink.table.planner.calcite.{FlinkContext, FlinkTypeFactory}
 import org.apache.flink.table.planner.plan.`trait`.FlinkRelDistribution
 import org.apache.flink.table.planner.plan.nodes.FlinkConventions
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalAggregate
@@ -80,7 +80,7 @@ class BatchExecSortAggRule
     val (auxGroupSet, aggCallsWithoutAuxGroupCalls) = AggregateUtil.checkAndSplitAggCalls(agg)
 
     val (_, aggBufferTypes, aggFunctions) = AggregateUtil.transformToBatchAggregateFunctions(
-      aggCallsWithoutAuxGroupCalls, inputRowType)
+      FlinkTypeFactory.toLogicalRowType(inputRowType), aggCallsWithoutAuxGroupCalls)
     val groupSet = agg.getGroupSet.toArray
     val aggCallToAggFunction = aggCallsWithoutAuxGroupCalls.zip(aggFunctions)
     // TODO aggregate include projection now, so do not provide new trait will be safe
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecWindowAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecWindowAggregateRule.scala
index e179187..81151f2 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecWindowAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/BatchExecWindowAggregateRule.scala
@@ -101,7 +101,7 @@ class BatchExecWindowAggregateRule
     val (auxGroupSet, aggCallsWithoutAuxGroupCalls) = AggregateUtil.checkAndSplitAggCalls(agg)
 
     val (_, aggBufferTypes, aggregates) = AggregateUtil.transformToBatchAggregateFunctions(
-      aggCallsWithoutAuxGroupCalls, input.getRowType)
+      FlinkTypeFactory.toLogicalRowType(input.getRowType), aggCallsWithoutAuxGroupCalls)
     val aggCallToAggFunction = aggCallsWithoutAuxGroupCalls.zip(aggregates)
     val internalAggBufferTypes = aggBufferTypes.map(_.map(fromDataTypeToLogicalType))
     val tableConfig = call.getPlanner.getContext.unwrap(classOf[FlinkContext]).getTableConfig
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/EnforceLocalAggRuleBase.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/EnforceLocalAggRuleBase.scala
index 1ff432e..34a4de2 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/EnforceLocalAggRuleBase.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/batch/EnforceLocalAggRuleBase.scala
@@ -19,9 +19,10 @@
 package org.apache.flink.table.planner.plan.rules.physical.batch
 
 import org.apache.flink.table.api.TableException
+import org.apache.flink.table.planner.calcite.FlinkTypeFactory
 import org.apache.flink.table.planner.plan.`trait`.FlinkRelDistribution
 import org.apache.flink.table.planner.plan.nodes.FlinkConventions
-import org.apache.flink.table.planner.plan.nodes.physical.batch.{BatchPhysicalExpand, BatchExecGroupAggregateBase, BatchExecHashAggregate, BatchExecSortAggregate, BatchPhysicalExchange}
+import org.apache.flink.table.planner.plan.nodes.physical.batch.{BatchExecGroupAggregateBase, BatchExecHashAggregate, BatchExecSortAggregate, BatchPhysicalExchange, BatchPhysicalExpand}
 import org.apache.flink.table.planner.plan.utils.{AggregateUtil, FlinkRelOptUtil}
 
 import org.apache.calcite.plan.{RelOptRule, RelOptRuleOperand}
@@ -75,7 +76,7 @@ abstract class EnforceLocalAggRuleBase(
     val aggCallToAggFunction = completeAgg.getAggCallToAggFunction
 
     val (_, aggBufferTypes, _) = AggregateUtil.transformToBatchAggregateFunctions(
-      aggCalls, inputRowType)
+      FlinkTypeFactory.toLogicalRowType(inputRowType), aggCalls)
 
     val traitSet = cluster.getPlanner
       .emptyTraitSet
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
index a9e8628..a0bb8fd 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
@@ -132,9 +132,9 @@ class IncrementalAggregateRule
     } else {
       // an additional count1 is inserted, need to adapt the global agg
       val localAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
-        aggCalls,
         // the final agg input is partial agg
-        partialGlobalAgg.getRowType,
+        FlinkTypeFactory.toLogicalRowType(partialGlobalAgg.getRowType),
+        aggCalls,
         // all the aggs do not need retraction
         Array.fill(aggCalls.length)(false),
         // also do not need count*
@@ -142,9 +142,9 @@ class IncrementalAggregateRule
         // the local agg is not works on state
         isStateBackendDataViews = false)
       val globalAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
-        aggCalls,
         // the final agg input is partial agg
-        partialGlobalAgg.getRowType,
+        FlinkTypeFactory.toLogicalRowType(partialGlobalAgg.getRowType),
+        aggCalls,
         // all the aggs do not need retraction
         Array.fill(aggCalls.length)(false),
         // also do not need count*
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
index 11a6281..afb24fb 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
@@ -66,11 +66,11 @@ class TwoStageOptimizedAggregateRule extends RelOptRule(
     val fmq = FlinkRelMetadataQuery.reuseOrCreate(call.getMetadataQuery)
     val monotonicity = fmq.getRelModifiedMonotonicity(agg)
     val needRetractionArray = AggregateUtil.getNeedRetractions(
-      agg.grouping.length, needRetraction, monotonicity, agg.aggCalls)
+      agg.grouping.length, agg.aggCalls, needRetraction, monotonicity)
 
     val aggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
+      FlinkTypeFactory.toLogicalRowType( agg.getInput.getRowType),
       agg.aggCalls,
-      agg.getInput.getRowType,
       needRetractionArray,
       needRetraction,
       isStateBackendDataViews = true)
@@ -98,18 +98,18 @@ class TwoStageOptimizedAggregateRule extends RelOptRule(
     val fmq = FlinkRelMetadataQuery.reuseOrCreate(call.getMetadataQuery)
     val monotonicity = fmq.getRelModifiedMonotonicity(agg)
     val needRetractionArray = AggregateUtil.getNeedRetractions(
-      agg.grouping.length, needRetraction, monotonicity, agg.aggCalls)
+      agg.grouping.length, agg.aggCalls, needRetraction, monotonicity)
 
     val localAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
+      FlinkTypeFactory.toLogicalRowType(realInput.getRowType),
       agg.aggCalls,
-      realInput.getRowType,
       needRetractionArray,
       needRetraction,
       isStateBackendDataViews = false)
 
     val globalAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
+      FlinkTypeFactory.toLogicalRowType(realInput.getRowType),
       agg.aggCalls,
-      realInput.getRowType,
       needRetractionArray,
       needRetraction,
       isStateBackendDataViews = true)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggFunctionFactory.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggFunctionFactory.scala
index 798e256..bfe82e6 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggFunctionFactory.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggFunctionFactory.scala
@@ -19,24 +19,17 @@ package org.apache.flink.table.planner.plan.utils
 
 import org.apache.flink.table.api.TableException
 import org.apache.flink.table.functions.UserDefinedFunction
-import org.apache.flink.table.planner.calcite.FlinkTypeFactory
-import org.apache.flink.table.planner.functions.aggfunctions.FirstValueAggFunction._
-import org.apache.flink.table.planner.functions.aggfunctions.FirstValueWithRetractAggFunction._
 import org.apache.flink.table.planner.functions.aggfunctions.IncrSumAggFunction._
 import org.apache.flink.table.planner.functions.aggfunctions.IncrSumWithRetractAggFunction._
-import org.apache.flink.table.planner.functions.aggfunctions.LastValueAggFunction._
-import org.apache.flink.table.planner.functions.aggfunctions.LastValueWithRetractAggFunction._
 import org.apache.flink.table.planner.functions.aggfunctions.SingleValueAggFunction._
 import org.apache.flink.table.planner.functions.aggfunctions.SumWithRetractAggFunction._
 import org.apache.flink.table.planner.functions.aggfunctions._
 import org.apache.flink.table.planner.functions.bridging.BridgingSqlAggFunction
 import org.apache.flink.table.planner.functions.sql.{SqlFirstLastValueAggFunction, SqlListAggFunction}
 import org.apache.flink.table.planner.functions.utils.AggSqlFunction
-import org.apache.flink.table.runtime.typeutils.DecimalDataTypeInfo
 import org.apache.flink.table.types.logical.LogicalTypeRoot._
 import org.apache.flink.table.types.logical._
 
-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, SqlRankFunction}
@@ -49,14 +42,14 @@ 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
+  * @param inputRowType the input's output RowType
+  * @param orderKeyIndexes the indexes of order key (null when is not over agg)
+  * @param aggCallNeedRetractions true if need retraction
   */
 class AggFunctionFactory(
-    inputType: RelDataType,
-    orderKeyIdx: Array[Int],
-    needRetraction: Array[Boolean]) {
+    inputRowType: RowType,
+    orderKeyIndexes: Array[Int],
+    aggCallNeedRetractions: Array[Boolean]) {
 
   /**
     * The entry point to create an aggregate function from the given AggregateCall
@@ -64,8 +57,7 @@ class AggFunctionFactory(
   def createAggFunction(call: AggregateCall, index: Int): UserDefinedFunction = {
 
     val argTypes: Array[LogicalType] = call.getArgList
-      .map(inputType.getFieldList.get(_).getType)
-      .map(FlinkTypeFactory.toLogicalType)
+      .map(inputRowType.getChildren.get(_))
       .toArray
 
     call.getAggregation match {
@@ -165,7 +157,7 @@ class AggFunctionFactory(
   private def createSumAggFunction(
       argTypes: Array[LogicalType],
       index: Int): UserDefinedFunction = {
-    if (needRetraction(index)) {
+    if (aggCallNeedRetractions(index)) {
       argTypes(0).getTypeRoot match {
         case TINYINT =>
           new ByteSumWithRetractAggFunction
@@ -236,7 +228,7 @@ class AggFunctionFactory(
   private def createIncrSumAggFunction(
       argTypes: Array[LogicalType],
       index: Int): UserDefinedFunction = {
-    if (needRetraction(index)) {
+    if (aggCallNeedRetractions(index)) {
       argTypes(0).getTypeRoot match {
         case TINYINT =>
           new ByteIncrSumWithRetractAggFunction
@@ -286,7 +278,7 @@ class AggFunctionFactory(
       index: Int)
     : UserDefinedFunction = {
     val valueType = argTypes(0)
-    if (needRetraction(index)) {
+    if (aggCallNeedRetractions(index)) {
       valueType.getTypeRoot match {
         case TINYINT | SMALLINT | INTEGER | BIGINT | FLOAT | DOUBLE | BOOLEAN | VARCHAR | DECIMAL |
              TIME_WITHOUT_TIME_ZONE | DATE | TIMESTAMP_WITHOUT_TIME_ZONE =>
@@ -370,7 +362,7 @@ class AggFunctionFactory(
         index: Int)
     : UserDefinedFunction = {
     val valueType = argTypes(0)
-    if (needRetraction(index)) {
+    if (aggCallNeedRetractions(index)) {
       valueType.getTypeRoot match {
         case TINYINT | SMALLINT | INTEGER | BIGINT | FLOAT | DOUBLE | BOOLEAN | VARCHAR | DECIMAL |
              TIME_WITHOUT_TIME_ZONE | DATE | TIMESTAMP_WITHOUT_TIME_ZONE =>
@@ -460,16 +452,12 @@ class AggFunctionFactory(
   }
 
   private def createRankAggFunction(argTypes: Array[LogicalType]): UserDefinedFunction = {
-    val argTypes = orderKeyIdx
-      .map(inputType.getFieldList.get(_).getType)
-      .map(FlinkTypeFactory.toLogicalType)
+    val argTypes = orderKeyIndexes.map(inputRowType.getChildren.get(_))
     new RankAggFunction(argTypes)
   }
 
   private def createDenseRankAggFunction(argTypes: Array[LogicalType]): UserDefinedFunction = {
-    val argTypes = orderKeyIdx
-      .map(inputType.getFieldList.get(_).getType)
-      .map(FlinkTypeFactory.toLogicalType)
+    val argTypes = orderKeyIndexes.map(inputRowType.getChildren.get(_))
     new DenseRankAggFunction(argTypes)
   }
 
@@ -478,7 +466,7 @@ class AggFunctionFactory(
       index: Int)
     : UserDefinedFunction = {
     val valueType = argTypes(0)
-    if (needRetraction(index)) {
+    if (aggCallNeedRetractions(index)) {
       valueType.getTypeRoot match {
         case TINYINT | SMALLINT | INTEGER | BIGINT | FLOAT | DOUBLE | BOOLEAN | VARCHAR | DECIMAL =>
           new FirstValueWithRetractAggFunction(valueType)
@@ -502,7 +490,7 @@ class AggFunctionFactory(
       index: Int)
     : UserDefinedFunction = {
     val valueType = argTypes(0)
-    if (needRetraction(index)) {
+    if (aggCallNeedRetractions(index)) {
       valueType.getTypeRoot match {
         case TINYINT | SMALLINT | INTEGER | BIGINT | FLOAT | DOUBLE | BOOLEAN | VARCHAR | DECIMAL =>
           new LastValueWithRetractAggFunction(valueType)
@@ -524,7 +512,7 @@ class AggFunctionFactory(
   private def createListAggFunction(
       argTypes: Array[LogicalType],
       index: Int): UserDefinedFunction = {
-    if (needRetraction(index)) {
+    if (aggCallNeedRetractions(index)) {
       new ListAggWithRetractAggFunction
     } else {
       new ListAggFunction(1)
@@ -534,7 +522,7 @@ class AggFunctionFactory(
   private def createListAggWsFunction(
       argTypes: Array[LogicalType],
       index: Int): UserDefinedFunction = {
-    if (needRetraction(index)) {
+    if (aggCallNeedRetractions(index)) {
       new ListAggWsWithRetractAggFunction
     } else {
       new ListAggFunction(2)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala
index d3bf852..01fd4d4 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala
@@ -151,12 +151,12 @@ object AggregateUtil extends Enumeration {
   def getOutputIndexToAggCallIndexMap(
       aggregateCalls: Seq[AggregateCall],
       inputType: RelDataType,
-      orderKeyIdx: Array[Int] = null): util.Map[Integer, Integer] = {
+      orderKeyIndexes: Array[Int] = null): util.Map[Integer, Integer] = {
     val aggInfos = transformToAggregateInfoList(
+      FlinkTypeFactory.toLogicalRowType(inputType),
       aggregateCalls,
-      inputType,
-      orderKeyIdx,
       Array.fill(aggregateCalls.size)(false),
+      orderKeyIndexes,
       needInputCount = false,
       isStateBackedDataViews = false,
       needDistinctInfo = false).aggInfos
@@ -176,10 +176,10 @@ object AggregateUtil extends Enumeration {
   }
 
   def deriveAggregateInfoList(
-      aggNode: StreamPhysicalRel,
-      aggCalls: Seq[AggregateCall],
-      grouping: Array[Int]): AggregateInfoList = {
-    val input = aggNode.getInput(0)
+      agg: StreamPhysicalRel,
+      groupCount: Int,
+      aggCalls: Seq[AggregateCall]): AggregateInfoList = {
+    val input = agg.getInput(0)
     // need to call `retract()` if input contains update or delete
     val modifyKindSetTrait = input.getTraitSet.getTrait(ModifyKindSetTraitDef.INSTANCE)
     val needRetraction = if (modifyKindSetTrait == null) {
@@ -188,29 +188,28 @@ object AggregateUtil extends Enumeration {
     } else {
       !modifyKindSetTrait.modifyKindSet.isInsertOnly
     }
-    val fmq = FlinkRelMetadataQuery.reuseOrCreate(aggNode.getCluster.getMetadataQuery)
-    val monotonicity = fmq.getRelModifiedMonotonicity(aggNode)
-    val needRetractionArray = AggregateUtil.getNeedRetractions(
-      grouping.length, needRetraction, monotonicity, aggCalls)
-    AggregateUtil.transformToStreamAggregateInfoList(
+    val fmq = FlinkRelMetadataQuery.reuseOrCreate(agg.getCluster.getMetadataQuery)
+    val monotonicity = fmq.getRelModifiedMonotonicity(agg)
+    val needRetractionArray = getNeedRetractions(groupCount, aggCalls, needRetraction, monotonicity)
+    transformToStreamAggregateInfoList(
+      FlinkTypeFactory.toLogicalRowType(input.getRowType),
       aggCalls,
-      input.getRowType,
       needRetractionArray,
       needInputCount = needRetraction,
       isStateBackendDataViews = true)
   }
 
   def transformToBatchAggregateFunctions(
+      inputRowType: RowType,
       aggregateCalls: Seq[AggregateCall],
-      inputRowType: RelDataType,
-      orderKeyIdx: Array[Int] = null)
+      orderKeyIndexes: Array[Int] = null)
   : (Array[Array[Int]], Array[Array[DataType]], Array[UserDefinedFunction]) = {
 
     val aggInfos = transformToAggregateInfoList(
-      aggregateCalls,
       inputRowType,
-      orderKeyIdx,
+      aggregateCalls,
       Array.fill(aggregateCalls.size)(false),
+      orderKeyIndexes,
       needInputCount = false,
       isStateBackedDataViews = false,
       needDistinctInfo = false).aggInfos
@@ -223,39 +222,39 @@ object AggregateUtil extends Enumeration {
   }
 
   def transformToBatchAggregateInfoList(
-      aggregateCalls: Seq[AggregateCall],
-      inputRowType: RelDataType,
-      orderKeyIdx: Array[Int] = null,
-      needRetractions: Array[Boolean] = null): AggregateInfoList = {
+      inputRowType: RowType,
+      aggCalls: Seq[AggregateCall],
+      aggCallNeedRetractions: Array[Boolean] = null,
+      orderKeyIndexes: Array[Int] = null): AggregateInfoList = {
 
-    val needRetractionArray = if (needRetractions == null) {
-      Array.fill(aggregateCalls.size)(false)
+    val finalAggCallNeedRetractions = if (aggCallNeedRetractions == null) {
+      Array.fill(aggCalls.size)(false)
     } else {
-      needRetractions
+      aggCallNeedRetractions
     }
 
     transformToAggregateInfoList(
-      aggregateCalls,
       inputRowType,
-      orderKeyIdx,
-      needRetractionArray,
+      aggCalls,
+      finalAggCallNeedRetractions,
+      orderKeyIndexes,
       needInputCount = false,
       isStateBackedDataViews = false,
       needDistinctInfo = false)
   }
 
   def transformToStreamAggregateInfoList(
+      inputRowType: RowType,
       aggregateCalls: Seq[AggregateCall],
-      inputRowType: RelDataType,
-      needRetraction: Array[Boolean],
+      aggCallNeedRetractions: Array[Boolean],
       needInputCount: Boolean,
       isStateBackendDataViews: Boolean,
       needDistinctInfo: Boolean = true): AggregateInfoList = {
     transformToAggregateInfoList(
-      aggregateCalls,
       inputRowType,
-      orderKeyIdx = null,
-      needRetraction ++ Array(needInputCount), // for additional count(*)
+      aggregateCalls,
+      aggCallNeedRetractions ++ Array(needInputCount), // for additional count(*)
+      orderKeyIndexes = null,
       needInputCount,
       isStateBackendDataViews,
       needDistinctInfo)
@@ -264,10 +263,10 @@ object AggregateUtil extends Enumeration {
   /**
     * Transforms calcite aggregate calls to AggregateInfos.
     *
+    * @param inputRowType     the input's output RowType
     * @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 aggCallNeedRetractions   whether the aggregate function need retract method
+    * @param orderKeyIndexes      the index of order by field in the input, null if not over agg
     * @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.
@@ -275,10 +274,10 @@ object AggregateUtil extends Enumeration {
     * @param needDistinctInfo  whether need to extract distinct information
     */
   private def transformToAggregateInfoList(
+      inputRowType: RowType,
       aggregateCalls: Seq[AggregateCall],
-      inputRowType: RelDataType,
-      orderKeyIdx: Array[Int],
-      needRetraction: Array[Boolean],
+      aggCallNeedRetractions: Array[Boolean],
+      orderKeyIndexes: Array[Int],
       needInputCount: Boolean,
       isStateBackedDataViews: Boolean,
       needDistinctInfo: Boolean): AggregateInfoList = {
@@ -301,12 +300,12 @@ object AggregateUtil extends Enumeration {
 
     // Step-3:
     // create aggregate information
-    val factory = new AggFunctionFactory(inputRowType, orderKeyIdx, needRetraction)
+    val factory = new AggFunctionFactory(inputRowType, orderKeyIndexes, aggCallNeedRetractions)
     val aggInfos = newAggCalls
       .zipWithIndex
       .map { case (call, index) =>
         val argIndexes = call.getAggregation match {
-          case _: SqlRankFunction => orderKeyIdx
+          case _: SqlRankFunction => orderKeyIndexes
           case _ => call.getArgList.map(_.intValue()).toArray
         }
         transformToAggregateInfo(
@@ -316,14 +315,14 @@ object AggregateUtil extends Enumeration {
           argIndexes,
           factory.createAggFunction(call, index),
           isStateBackedDataViews,
-          needRetraction(index))
+          aggCallNeedRetractions(index))
       }
 
     AggregateInfoList(aggInfos.toArray, indexOfCountStar, countStarInserted, distinctInfos)
   }
 
   private def transformToAggregateInfo(
-      inputRowRelDataType: RelDataType,
+      inputRowType: RowType,
       call: AggregateCall,
       index: Int,
       argIndexes: Array[Int],
@@ -334,7 +333,7 @@ object AggregateUtil extends Enumeration {
 
     case _: BridgingSqlAggFunction =>
       createAggregateInfoFromBridgingFunction(
-        inputRowRelDataType,
+        inputRowType,
         call,
         index,
         argIndexes,
@@ -344,7 +343,7 @@ object AggregateUtil extends Enumeration {
 
     case _: AggSqlFunction =>
       createAggregateInfoFromLegacyFunction(
-        inputRowRelDataType,
+        inputRowType,
         call,
         index,
         argIndexes,
@@ -363,7 +362,7 @@ object AggregateUtil extends Enumeration {
   }
 
   private def createAggregateInfoFromBridgingFunction(
-      inputRowRelDataType: RelDataType,
+      inputRowType: RowType,
       call: AggregateCall,
       index: Int,
       argIndexes: Array[Int],
@@ -387,7 +386,7 @@ object AggregateUtil extends Enumeration {
         function.getTypeFactory,
         function,
         SqlTypeUtil.projectTypes(
-          inputRowRelDataType,
+          FlinkTypeFactory.INSTANCE.buildRelNodeRowType(inputRowType),
           argIndexes.map(Int.box).toList),
         0,
         false))
@@ -490,7 +489,7 @@ object AggregateUtil extends Enumeration {
   }
 
   private def createAggregateInfoFromLegacyFunction(
-      inputRowRelDataType: RelDataType,
+      inputRowType: RowType,
       call: AggregateCall,
       index: Int,
       argIndexes: Array[Int],
@@ -507,8 +506,7 @@ object AggregateUtil extends Enumeration {
           }
           val externalAccType = getAccumulatorTypeOfAggregateFunction(a, implicitAccType)
           val argTypes = call.getArgList
-            .map(idx => inputRowRelDataType.getFieldList.get(idx).getType)
-            .map(FlinkTypeFactory.toLogicalType)
+            .map(idx => inputRowType.getChildren.get(idx))
           val externalArgTypes: Array[DataType] = getAggUserDefinedInputTypes(
             a,
             externalAccType,
@@ -605,7 +603,7 @@ object AggregateUtil extends Enumeration {
   private def extractDistinctInformation(
       needDistinctInfo: Boolean,
       aggCalls: Seq[AggregateCall],
-      inputType: RelDataType,
+      inputType: RowType,
       hasStateBackedDataViews: Boolean,
       consumeRetraction: Boolean): (Array[DistinctInfo], Seq[AggregateCall]) = {
 
@@ -621,8 +619,7 @@ object AggregateUtil extends Enumeration {
       if (call.isDistinct && !call.isApproximate && argIndexes.length > 0) {
         val argTypes: Array[LogicalType] = call
           .getArgList
-          .map(inputType.getFieldList.get(_).getType)
-          .map(FlinkTypeFactory.toLogicalType)
+          .map(inputType.getChildren.get(_))
           .toArray
 
         val keyType = createDistinctKeyType(argTypes)
@@ -790,9 +787,9 @@ object AggregateUtil extends Enumeration {
     */
   def getNeedRetractions(
       groupCount: Int,
+      aggCalls: Seq[AggregateCall],
       needRetraction: Boolean,
-      monotonicity: RelModifiedMonotonicity,
-      aggCalls: Seq[AggregateCall]): Array[Boolean] = {
+      monotonicity: RelModifiedMonotonicity): Array[Boolean] = {
     val needRetractionArray = Array.fill(aggCalls.size)(needRetraction)
     if (monotonicity != null && needRetraction) {
       aggCalls.zipWithIndex.foreach { case (aggCall, idx) =>
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
index e92b095..eaa38bf 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
@@ -952,7 +952,9 @@ class FlinkRelMdHandlerTestBase {
 
     val aggCalls = logicalAgg.getAggCallList
     val aggFunctionFactory = new AggFunctionFactory(
-      studentBatchScan.getRowType, Array.empty[Int], Array.fill(aggCalls.size())(false))
+      FlinkTypeFactory.toLogicalRowType(studentBatchScan.getRowType),
+      Array.empty[Int],
+      Array.fill(aggCalls.size())(false))
     val aggCallToAggFunction = aggCalls.zipWithIndex.map {
       case (call, index) => (call, aggFunctionFactory.createAggFunction(call, index))
     }
@@ -1018,11 +1020,11 @@ class FlinkRelMdHandlerTestBase {
       isMerge = false)
 
     val needRetractionArray = AggregateUtil.getNeedRetractions(
-      1, needRetraction = false, null, aggCalls)
+      1, aggCalls, needRetraction = false, null)
 
     val localAggInfoList = transformToStreamAggregateInfoList(
+      FlinkTypeFactory.toLogicalRowType(studentStreamScan.getRowType),
       aggCalls,
-      studentStreamScan.getRowType,
       needRetractionArray,
       needInputCount = false,
       isStateBackendDataViews = false)
@@ -1039,8 +1041,8 @@ class FlinkRelMdHandlerTestBase {
     val streamExchange1 = new StreamPhysicalExchange(
       cluster, streamLocalAgg.getTraitSet.replace(hash0), streamLocalAgg, hash0)
     val globalAggInfoList = transformToStreamAggregateInfoList(
+      FlinkTypeFactory.toLogicalRowType(streamExchange1.getRowType),
       aggCalls,
-      streamExchange1.getRowType,
       needRetractionArray,
       needInputCount = false,
       isStateBackendDataViews = true)
@@ -1103,7 +1105,9 @@ class FlinkRelMdHandlerTestBase {
       call => call.getAggregation != FlinkSqlOperatorTable.AUXILIARY_GROUP
     }
     val aggFunctionFactory = new AggFunctionFactory(
-      studentBatchScan.getRowType, Array.empty[Int], Array.fill(aggCalls.size())(false))
+      FlinkTypeFactory.toLogicalRowType(studentBatchScan.getRowType),
+      Array.empty[Int],
+      Array.fill(aggCalls.size())(false))
     val aggCallToAggFunction = aggCalls.zipWithIndex.map {
       case (call, index) => (call, aggFunctionFactory.createAggFunction(call, index))
     }
@@ -1245,7 +1249,8 @@ class FlinkRelMdHandlerTestBase {
       cluster, batchPhysicalTraits.replace(hash01), batchCalc, hash01)
     val (_, _, aggregates) =
       AggregateUtil.transformToBatchAggregateFunctions(
-        flinkLogicalWindowAgg.getAggCallList, batchExchange1.getRowType)
+        FlinkTypeFactory.toLogicalRowType(batchExchange1.getRowType),
+        flinkLogicalWindowAgg.getAggCallList)
     val aggCallToAggFunction = flinkLogicalWindowAgg.getAggCallList.zip(aggregates)
 
     val localWindowAggTypes =
@@ -1390,7 +1395,8 @@ class FlinkRelMdHandlerTestBase {
       cluster, batchPhysicalTraits.replace(hash1), batchCalc, hash1)
     val (_, _, aggregates) =
       AggregateUtil.transformToBatchAggregateFunctions(
-        flinkLogicalWindowAgg.getAggCallList, batchExchange1.getRowType)
+        FlinkTypeFactory.toLogicalRowType(batchExchange1.getRowType),
+        flinkLogicalWindowAgg.getAggCallList)
     val aggCallToAggFunction = flinkLogicalWindowAgg.getAggCallList.zip(aggregates)
 
     val localWindowAggTypes =
@@ -1538,7 +1544,8 @@ class FlinkRelMdHandlerTestBase {
     val aggCallsWithoutAuxGroup = flinkLogicalWindowAggWithAuxGroup.getAggCallList.drop(1)
     val (_, _, aggregates) =
       AggregateUtil.transformToBatchAggregateFunctions(
-        aggCallsWithoutAuxGroup, batchExchange1.getRowType)
+        FlinkTypeFactory.toLogicalRowType(batchExchange1.getRowType),
+        aggCallsWithoutAuxGroup)
     val aggCallToAggFunction = aggCallsWithoutAuxGroup.zip(aggregates)
 
     val localWindowAggTypes =
@@ -2438,7 +2445,9 @@ class FlinkRelMdHandlerTestBase {
     ).build().asInstanceOf[LogicalAggregate]
     val aggCalls = logicalAgg.getAggCallList
     val aggFunctionFactory = new AggFunctionFactory(
-      studentBatchScan.getRowType, Array.empty[Int], Array.fill(aggCalls.size())(false))
+      FlinkTypeFactory.toLogicalRowType(studentBatchScan.getRowType),
+      Array.empty[Int],
+      Array.fill(aggCalls.size())(false))
     val aggCallToAggFunction = aggCalls.zipWithIndex.map {
       case (call, index) => (call, aggFunctionFactory.createAggFunction(call, index))
     }

[flink] 08/08: [FLINK-20737][table-planner-blink] Introduce StreamPhysicalPythonGroupTableAggregate, and make StreamExecPythonGroupTableAggregate only extended from ExecNode

Posted by go...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 45417078b3da3ee81113e393733b834e2b786056
Author: godfreyhe <go...@163.com>
AuthorDate: Wed Dec 23 19:45:14 2020 +0800

    [FLINK-20737][table-planner-blink] Introduce StreamPhysicalPythonGroupTableAggregate, and make StreamExecPythonGroupTableAggregate only extended from ExecNode
    
    This closes #14478
---
 ...reamPhysicalPythonGroupTableAggregateRule.java} | 21 +++--
 .../StreamExecPythonGroupTableAggregate.scala      | 89 ++++++++++------------
 .../StreamPhysicalPythonGroupTableAggregate.scala  | 76 ++++++++++++++++++
 .../FlinkChangelogModeInferenceProgram.scala       |  2 +-
 .../planner/plan/rules/FlinkStreamRuleSets.scala   |  2 +-
 5 files changed, 126 insertions(+), 64 deletions(-)

diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecPythonGroupTableAggregateRule.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalPythonGroupTableAggregateRule.java
similarity index 87%
rename from flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecPythonGroupTableAggregateRule.java
rename to flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalPythonGroupTableAggregateRule.java
index d8465c6..81bd1465 100644
--- a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecPythonGroupTableAggregateRule.java
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalPythonGroupTableAggregateRule.java
@@ -22,9 +22,10 @@ import org.apache.flink.table.api.TableException;
 import org.apache.flink.table.functions.python.PythonFunctionKind;
 import org.apache.flink.table.planner.plan.nodes.FlinkConventions;
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalTableAggregate;
-import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamExecPythonGroupTableAggregate;
+import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamPhysicalPythonGroupTableAggregate;
 import org.apache.flink.table.planner.plan.trait.FlinkRelDistribution;
 import org.apache.flink.table.planner.plan.utils.PythonUtil;
+import org.apache.flink.table.planner.utils.JavaScalaConversionUtil;
 
 import org.apache.calcite.plan.RelOptRule;
 import org.apache.calcite.plan.RelOptRuleCall;
@@ -35,22 +36,20 @@ import org.apache.calcite.rel.core.AggregateCall;
 
 import java.util.List;
 
-import scala.collection.JavaConverters;
-
 /**
  * Rule to convert a {@link FlinkLogicalTableAggregate} into a {@link
- * StreamExecPythonGroupTableAggregate}.
+ * StreamPhysicalPythonGroupTableAggregateRule}.
  */
-public class StreamExecPythonGroupTableAggregateRule extends ConverterRule {
+public class StreamPhysicalPythonGroupTableAggregateRule extends ConverterRule {
 
-    public static final RelOptRule INSTANCE = new StreamExecPythonGroupTableAggregateRule();
+    public static final RelOptRule INSTANCE = new StreamPhysicalPythonGroupTableAggregateRule();
 
-    public StreamExecPythonGroupTableAggregateRule() {
+    public StreamPhysicalPythonGroupTableAggregateRule() {
         super(
                 FlinkLogicalTableAggregate.class,
                 FlinkConventions.LOGICAL(),
                 FlinkConventions.STREAM_PHYSICAL(),
-                "StreamExecPythonGroupTableAggregateRule");
+                "StreamPhysicalPythonGroupTableAggregateRule");
     }
 
     @Override
@@ -106,14 +105,12 @@ public class StreamExecPythonGroupTableAggregateRule extends ConverterRule {
                 rel.getTraitSet().replace(FlinkConventions.STREAM_PHYSICAL());
         RelNode newInput = RelOptRule.convert(agg.getInput(), requiredTraitSet);
 
-        return new StreamExecPythonGroupTableAggregate(
+        return new StreamPhysicalPythonGroupTableAggregate(
                 rel.getCluster(),
                 providedTraitSet,
                 newInput,
                 rel.getRowType(),
                 agg.getGroupSet().toArray(),
-                JavaConverters.asScalaIteratorConverter(agg.getAggCallList().iterator())
-                        .asScala()
-                        .toSeq());
+                JavaScalaConversionUtil.toScala(agg.getAggCallList()));
     }
 }
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupTableAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecPythonGroupTableAggregate.scala
similarity index 72%
rename from flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupTableAggregate.scala
rename to flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecPythonGroupTableAggregate.scala
index 1251043..ea38246 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupTableAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecPythonGroupTableAggregate.scala
@@ -15,7 +15,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.flink.table.planner.plan.nodes.physical.stream
+
+package org.apache.flink.table.planner.plan.nodes.exec.stream
 
 import org.apache.flink.api.dag.Transformation
 import org.apache.flink.configuration.Configuration
@@ -24,54 +25,41 @@ import org.apache.flink.streaming.api.operators.OneInputStreamOperator
 import org.apache.flink.streaming.api.transformations.OneInputTransformation
 import org.apache.flink.table.data.RowData
 import org.apache.flink.table.functions.python.PythonAggregateFunctionInfo
-import org.apache.flink.table.planner.calcite.FlinkTypeFactory
-import org.apache.flink.table.planner.delegation.StreamPlanner
-import org.apache.flink.table.planner.plan.nodes.exec.LegacyStreamExecNode
+import org.apache.flink.table.planner.delegation.PlannerBase
 import org.apache.flink.table.planner.plan.nodes.exec.common.CommonExecPythonAggregate
-import org.apache.flink.table.planner.plan.utils.{ChangelogPlanUtils, KeySelectorUtil}
+import org.apache.flink.table.planner.plan.nodes.exec.{ExecEdge, ExecNode, ExecNodeBase}
+import org.apache.flink.table.planner.plan.utils.{AggregateUtil, KeySelectorUtil}
 import org.apache.flink.table.planner.typeutils.DataViewUtils.DataViewSpec
+import org.apache.flink.table.planner.utils.Logging
 import org.apache.flink.table.runtime.typeutils.InternalTypeInfo
 import org.apache.flink.table.types.logical.RowType
 
-import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
-import org.apache.calcite.rel.RelNode
-import org.apache.calcite.rel.`type`.RelDataType
 import org.apache.calcite.rel.core.AggregateCall
 
-import java.util
+import java.util.Collections
 
 /**
-  * Stream physical RelNode for unbounded python group table aggregate.
-  */
+ * Stream [[ExecNode]] for unbounded python group table aggregate.
+ *
+ * <p>Note: This class can't be ported to Java,
+ * because java class can't extend scala interface with default implementation.
+ * FLINK-20750 will port this class to Java.
+ */
 class StreamExecPythonGroupTableAggregate(
-    cluster: RelOptCluster,
-    traitSet: RelTraitSet,
-    inputRel: RelNode,
-    outputRowType: RelDataType,
     grouping: Array[Int],
-    aggCalls: Seq[AggregateCall])
-  extends StreamPhysicalGroupTableAggregateBase(
-    cluster,
-    traitSet,
-    inputRel,
-    outputRowType,
-    grouping,
-    aggCalls)
-  with LegacyStreamExecNode[RowData]
-  with CommonExecPythonAggregate {
-
-  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
-    new StreamExecPythonGroupTableAggregate(
-      cluster,
-      traitSet,
-      inputs.get(0),
-      outputRowType,
-      grouping,
-      aggCalls)
-  }
-
-  override protected def translateToPlanInternal(
-      planner: StreamPlanner): Transformation[RowData] = {
+    aggCalls: Seq[AggregateCall],
+    aggCallNeedRetractions: Array[Boolean],
+    generateUpdateBefore: Boolean,
+    needRetraction: Boolean,
+    inputEdge: ExecEdge,
+    outputType: RowType,
+    description: String)
+  extends ExecNodeBase[RowData](Collections.singletonList(inputEdge), outputType, description)
+  with StreamExecNode[RowData]
+  with CommonExecPythonAggregate
+  with Logging {
+
+  override protected def translateToPlanInternal(planner: PlannerBase): Transformation[RowData] = {
     val tableConfig = planner.getTableConfig
 
     if (grouping.length > 0 && tableConfig.getMinIdleStateRetentionTime < 0) {
@@ -80,14 +68,17 @@ class StreamExecPythonGroupTableAggregate(
         "state size. You may specify a retention time of 0 to not clean up the state.")
     }
 
-    val inputTransformation = getInputNodes.get(0).translateToPlan(planner)
-      .asInstanceOf[Transformation[RowData]]
-
-    val outRowType = FlinkTypeFactory.toLogicalRowType(outputRowType)
-    val inputRowType = FlinkTypeFactory.toLogicalRowType(getInput.getRowType)
+    val inputNode = getInputNodes.get(0).asInstanceOf[ExecNode[RowData]]
+    val inputTransformation = inputNode.translateToPlan(planner)
 
-    val generateUpdateBefore = ChangelogPlanUtils.generateUpdateBefore(this)
+    val inputRowType = inputNode.getOutputType.asInstanceOf[RowType]
 
+    val aggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
+      inputRowType,
+      aggCalls,
+      aggCallNeedRetractions,
+      needRetraction,
+      isStateBackendDataViews = true)
     val inputCountIndex = aggInfoList.getIndexOfCountStar
 
     var (pythonFunctionInfos, dataViewSpecs) =
@@ -100,7 +91,7 @@ class StreamExecPythonGroupTableAggregate(
     val operator = getPythonTableAggregateFunctionOperator(
       getConfig(planner.getExecEnv, tableConfig),
       inputRowType,
-      outRowType,
+      outputType,
       pythonFunctionInfos,
       dataViewSpecs,
       tableConfig.getMinIdleStateRetentionTime,
@@ -109,16 +100,14 @@ class StreamExecPythonGroupTableAggregate(
       generateUpdateBefore,
       inputCountIndex)
 
-    val selector = KeySelectorUtil.getRowDataSelector(
-      grouping,
-      InternalTypeInfo.of(inputRowType))
+    val selector = KeySelectorUtil.getRowDataSelector(grouping, InternalTypeInfo.of(inputRowType))
 
     // partitioned aggregation
     val ret = new OneInputTransformation(
       inputTransformation,
-      getRelDetailedDescription,
+      getDesc,
       operator,
-      InternalTypeInfo.of(outRowType),
+      InternalTypeInfo.of(outputType),
       inputTransformation.getParallelism)
 
     if (inputsContainSingleton()) {
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalPythonGroupTableAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalPythonGroupTableAggregate.scala
new file mode 100644
index 0000000..9c373d1
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalPythonGroupTableAggregate.scala
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.flink.table.planner.plan.nodes.physical.stream
+
+import org.apache.flink.table.planner.calcite.FlinkTypeFactory
+import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecPythonGroupTableAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.{ExecEdge, ExecNode}
+import org.apache.flink.table.planner.plan.utils.{AggregateUtil, ChangelogPlanUtils}
+
+import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
+import org.apache.calcite.rel.RelNode
+import org.apache.calcite.rel.`type`.RelDataType
+import org.apache.calcite.rel.core.AggregateCall
+
+import java.util
+
+/**
+ * Stream physical RelNode for unbounded python group table aggregate.
+ */
+class StreamPhysicalPythonGroupTableAggregate(
+    cluster: RelOptCluster,
+    traitSet: RelTraitSet,
+    inputRel: RelNode,
+    outputRowType: RelDataType,
+    grouping: Array[Int],
+    aggCalls: Seq[AggregateCall])
+  extends StreamPhysicalGroupTableAggregateBase(
+    cluster,
+    traitSet,
+    inputRel,
+    outputRowType,
+    grouping,
+    aggCalls) {
+
+  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
+    new StreamPhysicalPythonGroupTableAggregate(
+      cluster,
+      traitSet,
+      inputs.get(0),
+      outputRowType,
+      grouping,
+      aggCalls)
+  }
+
+  override def translateToExecNode(): ExecNode[_] = {
+    val aggCallNeedRetractions =
+      AggregateUtil.deriveAggCallNeedRetractions(this, grouping.length, aggCalls)
+    val generateUpdateBefore = ChangelogPlanUtils.generateUpdateBefore(this)
+    val needRetraction = !ChangelogPlanUtils.inputInsertOnly(this)
+    new StreamExecPythonGroupTableAggregate(
+      grouping,
+      aggCalls,
+      aggCallNeedRetractions,
+      generateUpdateBefore,
+      needRetraction,
+      ExecEdge.DEFAULT,
+      FlinkTypeFactory.toLogicalRowType(getRowType),
+      getRelDetailedDescription
+    )
+  }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
index b7723fa..75f3a83 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
@@ -463,7 +463,7 @@ class FlinkChangelogModeInferenceProgram extends FlinkOptimizeProgram[StreamOpti
 
       case _: StreamPhysicalGroupAggregate | _: StreamPhysicalGroupTableAggregate |
            _: StreamPhysicalLimit | _: StreamPhysicalPythonGroupAggregate |
-           _: StreamExecPythonGroupTableAggregate =>
+           _: StreamPhysicalPythonGroupTableAggregate =>
         // Aggregate, TableAggregate and Limit requires update_before if there are updates
         val requiredChildTrait = beforeAfterOrNone(getModifyKindSet(rel.getInput(0)))
         val children = visitChildren(rel, requiredChildTrait)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
index d658e71..49ae726 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
@@ -423,7 +423,7 @@ object FlinkStreamRuleSets {
     StreamPhysicalGroupAggregateRule.INSTANCE,
     StreamPhysicalGroupTableAggregateRule.INSTANCE,
     StreamPhysicalPythonGroupAggregateRule.INSTANCE,
-    StreamExecPythonGroupTableAggregateRule.INSTANCE,
+    StreamPhysicalPythonGroupTableAggregateRule.INSTANCE,
     // over agg
     StreamExecOverAggregateRule.INSTANCE,
     StreamExecPythonOverAggregateRule.INSTANCE,

[flink] 04/08: [FLINK-20737][table-planner-blink] Introduce StreamPhysicalLocalGroupAggregate, and make StreamExecLocalGroupAggregate only extended from ExecNode

Posted by go...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit fa6412793ec1c11b751a51abc0c1492bf3079573
Author: godfreyhe <go...@163.com>
AuthorDate: Wed Dec 23 15:30:16 2020 +0800

    [FLINK-20737][table-planner-blink] Introduce StreamPhysicalLocalGroupAggregate, and make StreamExecLocalGroupAggregate only extended from ExecNode
    
    This closes #14478
---
 .../exec/stream/StreamExecLocalGroupAggregate.java | 129 +++++++++++++++++++
 .../plan/metadata/FlinkRelMdColumnInterval.scala   |   9 +-
 .../plan/metadata/FlinkRelMdColumnUniqueness.scala |   2 +-
 .../FlinkRelMdFilteredColumnInterval.scala         |   4 +-
 .../metadata/FlinkRelMdModifiedMonotonicity.scala  |   2 +-
 .../plan/metadata/FlinkRelMdUniqueKeys.scala       |   2 +-
 .../StreamExecIncrementalGroupAggregate.scala      |   6 +-
 .../stream/StreamExecLocalGroupAggregate.scala     | 142 ---------------------
 .../stream/StreamPhysicalLocalGroupAggregate.scala | 103 +++++++++++++++
 .../physical/stream/IncrementalAggregateRule.scala |  12 +-
 .../stream/TwoStageOptimizedAggregateRule.scala    |  48 +++----
 .../plan/metadata/FlinkRelMdHandlerTestBase.scala  |  24 ++--
 12 files changed, 286 insertions(+), 197 deletions(-)

diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecLocalGroupAggregate.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecLocalGroupAggregate.java
new file mode 100644
index 0000000..26aa171
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecLocalGroupAggregate.java
@@ -0,0 +1,129 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.flink.table.planner.plan.nodes.exec.stream;
+
+import org.apache.flink.api.dag.Transformation;
+import org.apache.flink.streaming.api.transformations.OneInputTransformation;
+import org.apache.flink.table.data.RowData;
+import org.apache.flink.table.planner.codegen.CodeGeneratorContext;
+import org.apache.flink.table.planner.codegen.agg.AggsHandlerCodeGenerator;
+import org.apache.flink.table.planner.delegation.PlannerBase;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecEdge;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecNode;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeBase;
+import org.apache.flink.table.planner.plan.utils.AggregateInfoList;
+import org.apache.flink.table.planner.plan.utils.AggregateUtil;
+import org.apache.flink.table.planner.plan.utils.KeySelectorUtil;
+import org.apache.flink.table.planner.utils.JavaScalaConversionUtil;
+import org.apache.flink.table.runtime.generated.GeneratedAggsHandleFunction;
+import org.apache.flink.table.runtime.keyselector.RowDataKeySelector;
+import org.apache.flink.table.runtime.operators.aggregate.MiniBatchLocalGroupAggFunction;
+import org.apache.flink.table.runtime.operators.bundle.MapBundleOperator;
+import org.apache.flink.table.runtime.typeutils.InternalTypeInfo;
+import org.apache.flink.table.types.logical.RowType;
+
+import org.apache.calcite.rel.core.AggregateCall;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+/** Stream {@link ExecNode} for unbounded local group aggregate. */
+public class StreamExecLocalGroupAggregate extends ExecNodeBase<RowData>
+        implements StreamExecNode<RowData> {
+
+    private final int[] grouping;
+    private final AggregateCall[] aggCalls;
+    /** Each element indicates whether the corresponding agg call needs `retract` method. */
+    private final boolean[] aggCallNeedRetractions;
+    /** Whether this node consumes retraction messages. */
+    private final boolean needRetraction;
+
+    public StreamExecLocalGroupAggregate(
+            int[] grouping,
+            AggregateCall[] aggCalls,
+            boolean[] aggCallNeedRetractions,
+            boolean needRetraction,
+            ExecEdge inputEdge,
+            RowType outputType,
+            String description) {
+        super(Collections.singletonList(inputEdge), outputType, description);
+        this.grouping = grouping;
+        this.aggCalls = aggCalls;
+        this.aggCallNeedRetractions = aggCallNeedRetractions;
+        this.needRetraction = needRetraction;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected Transformation<RowData> translateToPlanInternal(PlannerBase planner) {
+        final ExecNode<RowData> inputNode = (ExecNode<RowData>) getInputNodes().get(0);
+        final Transformation<RowData> inputTransform = inputNode.translateToPlan(planner);
+        final RowType inputRowType = (RowType) inputNode.getOutputType();
+
+        final AggsHandlerCodeGenerator generator =
+                new AggsHandlerCodeGenerator(
+                        new CodeGeneratorContext(planner.getTableConfig()),
+                        planner.getRelBuilder(),
+                        JavaScalaConversionUtil.toScala(inputRowType.getChildren()),
+                        // the local aggregate result will be buffered, so need copy
+                        true);
+        generator.needAccumulate().needMerge(0, true, null);
+        if (needRetraction) {
+            generator.needRetract();
+        }
+
+        final AggregateInfoList aggInfoList =
+                AggregateUtil.transformToStreamAggregateInfoList(
+                        inputRowType,
+                        JavaScalaConversionUtil.toScala(Arrays.asList(aggCalls)),
+                        aggCallNeedRetractions,
+                        needRetraction,
+                        false,
+                        true);
+        final GeneratedAggsHandleFunction aggsHandler =
+                generator.generateAggsHandler("GroupAggsHandler", aggInfoList);
+        final MiniBatchLocalGroupAggFunction aggFunction =
+                new MiniBatchLocalGroupAggFunction(aggsHandler);
+
+        final RowDataKeySelector selector =
+                KeySelectorUtil.getRowDataSelector(
+                        grouping, (InternalTypeInfo<RowData>) inputTransform.getOutputType());
+
+        final MapBundleOperator<RowData, RowData, RowData, RowData> operator =
+                new MapBundleOperator<>(
+                        aggFunction,
+                        AggregateUtil.createMiniBatchTrigger(planner.getTableConfig()),
+                        selector);
+
+        final OneInputTransformation<RowData, RowData> transform =
+                new OneInputTransformation<>(
+                        inputTransform,
+                        getDesc(),
+                        operator,
+                        InternalTypeInfo.of(getOutputType()),
+                        inputTransform.getParallelism());
+
+        if (inputsContainSingleton()) {
+            transform.setParallelism(1);
+            transform.setMaxParallelism(1);
+        }
+
+        return transform;
+    }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
index 2e33587..9978208 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
@@ -459,7 +459,7 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
     * @return interval of the given column on stream local group Aggregate
     */
   def getColumnInterval(
-      aggregate: StreamExecLocalGroupAggregate,
+      aggregate: StreamPhysicalLocalGroupAggregate,
       mq: RelMetadataQuery,
       index: Int): ValueInterval = estimateColumnIntervalOfAggregate(aggregate, mq, index)
 
@@ -536,7 +536,7 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
     val fmq = FlinkRelMetadataQuery.reuseOrCreate(mq)
     val groupSet = aggregate match {
       case agg: StreamPhysicalGroupAggregate => agg.grouping
-      case agg: StreamExecLocalGroupAggregate => agg.grouping
+      case agg: StreamPhysicalLocalGroupAggregate => agg.grouping
       case agg: StreamExecGlobalGroupAggregate => agg.grouping
       case agg: StreamExecIncrementalGroupAggregate => agg.partialAggGrouping
       case agg: StreamExecGroupWindowAggregate => agg.getGrouping
@@ -606,9 +606,8 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
             } else {
               null
             }
-          case agg: StreamExecLocalGroupAggregate =>
-            getAggCallFromLocalAgg(
-              aggCallIndex, agg.aggInfoList.getActualAggregateCalls, agg.getInput.getRowType)
+          case agg: StreamPhysicalLocalGroupAggregate =>
+            getAggCallFromLocalAgg(aggCallIndex, agg.aggCalls, agg.getInput.getRowType)
           case agg: StreamExecIncrementalGroupAggregate
             if agg.partialAggInfoList.getActualAggregateCalls.length > aggCallIndex =>
             agg.partialAggInfoList.getActualAggregateCalls(aggCallIndex)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala
index 5799ab0..13954d3 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala
@@ -357,7 +357,7 @@ class FlinkRelMdColumnUniqueness private extends MetadataHandler[BuiltInMetadata
   }
 
   def areColumnsUnique(
-      rel: StreamExecLocalGroupAggregate,
+      rel: StreamPhysicalLocalGroupAggregate,
       mq: RelMetadataQuery,
       columns: ImmutableBitSet,
       ignoreNulls: Boolean): JBoolean = null
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
index c851c96..5444b3b 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
@@ -20,7 +20,7 @@ package org.apache.flink.table.planner.plan.metadata
 import org.apache.flink.table.planner.plan.metadata.FlinkMetadata.FilteredColumnInterval
 import org.apache.flink.table.planner.plan.nodes.calcite.TableAggregate
 import org.apache.flink.table.planner.plan.nodes.physical.batch.BatchExecGroupAggregateBase
-import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecGlobalGroupAggregate, StreamPhysicalGroupAggregate, StreamExecGroupTableAggregate, StreamExecGroupWindowAggregate, StreamExecGroupWindowTableAggregate, StreamExecLocalGroupAggregate}
+import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecGlobalGroupAggregate, StreamExecGroupTableAggregate, StreamExecGroupWindowAggregate, StreamExecGroupWindowTableAggregate, StreamPhysicalGroupAggregate, StreamPhysicalLocalGroupAggregate}
 import org.apache.flink.table.planner.plan.stats.ValueInterval
 import org.apache.flink.table.planner.plan.utils.ColumnIntervalUtil
 import org.apache.flink.util.Preconditions.checkArgument
@@ -200,7 +200,7 @@ class FlinkRelMdFilteredColumnInterval private extends MetadataHandler[FilteredC
   }
 
   def getFilteredColumnInterval(
-      aggregate: StreamExecLocalGroupAggregate,
+      aggregate: StreamPhysicalLocalGroupAggregate,
       mq: RelMetadataQuery,
       columnIndex: Int,
       filterArg: Int): ValueInterval = {
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
index d46ac17..1f2e1ee 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
@@ -297,7 +297,7 @@ class FlinkRelMdModifiedMonotonicity private extends MetadataHandler[ModifiedMon
   }
 
   def getRelModifiedMonotonicity(
-      rel: StreamExecLocalGroupAggregate,
+      rel: StreamPhysicalLocalGroupAggregate,
       mq: RelMetadataQuery): RelModifiedMonotonicity = {
     getRelModifiedMonotonicityOnAggregate(rel.getInput, mq, rel.aggCalls.toList, rel.grouping)
   }
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala
index bf9c1eb..96c5a9b 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala
@@ -352,7 +352,7 @@ class FlinkRelMdUniqueKeys private extends MetadataHandler[BuiltInMetadata.Uniqu
   }
 
   def getUniqueKeys(
-      rel: StreamExecLocalGroupAggregate,
+      rel: StreamPhysicalLocalGroupAggregate,
       mq: RelMetadataQuery,
       ignoreNulls: Boolean): JSet[ImmutableBitSet] = null
 
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
index 9706253..556c4fc 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
@@ -50,10 +50,10 @@ import scala.collection.JavaConversions._
   * {{{
   *   StreamExecGlobalGroupAggregate (final-global-aggregate)
   *   +- StreamPhysicalExchange
-  *      +- StreamExecLocalGroupAggregate (final-local-aggregate)
+  *      +- StreamPhysicalLocalGroupAggregate (final-local-aggregate)
   *         +- StreamExecGlobalGroupAggregate (partial-global-aggregate)
   *            +- StreamPhysicalExchange
-  *               +- StreamExecLocalGroupAggregate (partial-local-aggregate)
+  *               +- StreamPhysicalLocalGroupAggregate (partial-local-aggregate)
   * }}}
   *
   * partial-global-aggregate and final-local-aggregate can be combined as
@@ -64,7 +64,7 @@ import scala.collection.JavaConversions._
   *   +- StreamPhysicalExchange
   *      +- StreamExecIncrementalGroupAggregate
   *         +- StreamPhysicalExchange
-  *            +- StreamExecLocalGroupAggregate (partial-local-aggregate)
+  *            +- StreamPhysicalLocalGroupAggregate (partial-local-aggregate)
   * }}}
   *
   * @see [[StreamPhysicalGroupAggregateBase]] for more info.
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecLocalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecLocalGroupAggregate.scala
deleted file mode 100644
index 730695c..0000000
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecLocalGroupAggregate.scala
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.flink.table.planner.plan.nodes.physical.stream
-
-import org.apache.flink.api.dag.Transformation
-import org.apache.flink.api.java.functions.KeySelector
-import org.apache.flink.streaming.api.transformations.OneInputTransformation
-import org.apache.flink.table.data.RowData
-import org.apache.flink.table.planner.calcite.FlinkTypeFactory
-import org.apache.flink.table.planner.codegen.CodeGeneratorContext
-import org.apache.flink.table.planner.codegen.agg.AggsHandlerCodeGenerator
-import org.apache.flink.table.planner.delegation.StreamPlanner
-import org.apache.flink.table.planner.plan.PartialFinalType
-import org.apache.flink.table.planner.plan.nodes.exec.LegacyStreamExecNode
-import org.apache.flink.table.planner.plan.utils.{KeySelectorUtil, _}
-import org.apache.flink.table.runtime.operators.aggregate.MiniBatchLocalGroupAggFunction
-import org.apache.flink.table.runtime.operators.bundle.MapBundleOperator
-import org.apache.flink.table.runtime.typeutils.InternalTypeInfo
-
-import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
-import org.apache.calcite.rel.`type`.RelDataType
-import org.apache.calcite.rel.core.AggregateCall
-import org.apache.calcite.rel.{RelNode, RelWriter}
-
-import java.util
-
-import scala.collection.JavaConversions._
-
-/**
-  * Stream physical RelNode for unbounded local group aggregate.
-  *
-  * @see [[StreamPhysicalGroupAggregateBase]] for more info.
-  */
-class StreamExecLocalGroupAggregate(
-    cluster: RelOptCluster,
-    traitSet: RelTraitSet,
-    inputRel: RelNode,
-    outputRowType: RelDataType,
-    val grouping: Array[Int],
-    val aggCalls: Seq[AggregateCall],
-    val aggInfoList: AggregateInfoList,
-    val partialFinalType: PartialFinalType)
-  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel)
-  with LegacyStreamExecNode[RowData] {
-
-  override def requireWatermark: Boolean = false
-
-  override def deriveRowType(): RelDataType = outputRowType
-
-  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
-    new StreamExecLocalGroupAggregate(
-      cluster,
-      traitSet,
-      inputs.get(0),
-      outputRowType,
-      grouping,
-      aggCalls,
-      aggInfoList,
-      partialFinalType)
-  }
-
-  override def explainTerms(pw: RelWriter): RelWriter = {
-    val inputRowType = getInput.getRowType
-    super.explainTerms(pw)
-      .itemIf("groupBy", RelExplainUtil.fieldToString(grouping, inputRowType),
-        grouping.nonEmpty)
-      .itemIf("partialFinalType", partialFinalType, partialFinalType != PartialFinalType.NONE)
-      .item("select", RelExplainUtil.streamGroupAggregationToString(
-        inputRowType,
-        getRowType,
-        aggInfoList,
-        grouping,
-        isLocal = true))
-  }
-
-  //~ ExecNode methods -----------------------------------------------------------
-
-  override protected def translateToPlanInternal(
-      planner: StreamPlanner): Transformation[RowData] = {
-    val inputTransformation = getInputNodes.get(0).translateToPlan(planner)
-      .asInstanceOf[Transformation[RowData]]
-    val inRowType = FlinkTypeFactory.toLogicalRowType(getInput.getRowType)
-    val outRowType = FlinkTypeFactory.toLogicalRowType(outputRowType)
-
-    val needRetraction = !ChangelogPlanUtils.inputInsertOnly(this)
-
-    val generator = new AggsHandlerCodeGenerator(
-      CodeGeneratorContext(planner.getTableConfig),
-      planner.getRelBuilder,
-      inRowType.getChildren,
-      // the local aggregate result will be buffered, so need copy
-      copyInputField = true)
-
-    generator
-      .needAccumulate()
-      .needMerge(mergedAccOffset = 0, mergedAccOnHeap = true)
-
-    if (needRetraction) {
-      generator.needRetract()
-    }
-
-    val aggsHandler = generator.generateAggsHandler("GroupAggsHandler", aggInfoList)
-    val aggFunction = new MiniBatchLocalGroupAggFunction(aggsHandler)
-
-    val inputTypeInfo = inputTransformation.getOutputType.asInstanceOf[InternalTypeInfo[RowData]]
-    val selector = KeySelectorUtil.getRowDataSelector(grouping, inputTypeInfo)
-
-    val operator = new MapBundleOperator(
-      aggFunction,
-      AggregateUtil.createMiniBatchTrigger(planner.getTableConfig),
-      selector.asInstanceOf[KeySelector[RowData, RowData]])
-
-    val transformation = new OneInputTransformation(
-      inputTransformation,
-      getRelDetailedDescription,
-      operator,
-      InternalTypeInfo.of(outRowType),
-      inputTransformation.getParallelism)
-
-    if (inputsContainSingleton()) {
-      transformation.setParallelism(1)
-      transformation.setMaxParallelism(1)
-    }
-
-    transformation
-  }
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalLocalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalLocalGroupAggregate.scala
new file mode 100644
index 0000000..f750e6e
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalLocalGroupAggregate.scala
@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.flink.table.planner.plan.nodes.physical.stream
+
+import org.apache.flink.table.planner.calcite.FlinkTypeFactory
+import org.apache.flink.table.planner.plan.PartialFinalType
+import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecLocalGroupAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.{ExecEdge, ExecNode}
+import org.apache.flink.table.planner.plan.utils._
+
+import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
+import org.apache.calcite.rel.`type`.RelDataType
+import org.apache.calcite.rel.core.AggregateCall
+import org.apache.calcite.rel.{RelNode, RelWriter}
+
+import java.util
+
+/**
+ * Stream physical RelNode for unbounded local group aggregate.
+ *
+ * @see [[StreamPhysicalGroupAggregateBase]] for more info.
+ */
+class StreamPhysicalLocalGroupAggregate(
+    cluster: RelOptCluster,
+    traitSet: RelTraitSet,
+    inputRel: RelNode,
+    val grouping: Array[Int],
+    val aggCalls: Seq[AggregateCall],
+    aggCallNeedRetractions: Array[Boolean],
+    needRetraction: Boolean,
+    val partialFinalType: PartialFinalType)
+  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel) {
+
+  private lazy val aggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
+    FlinkTypeFactory.toLogicalRowType(inputRel.getRowType),
+    aggCalls,
+    aggCallNeedRetractions,
+    needRetraction,
+    isStateBackendDataViews = false)
+
+  override def requireWatermark: Boolean = false
+
+  override def deriveRowType(): RelDataType = {
+    AggregateUtil.inferLocalAggRowType(
+      aggInfoList,
+      inputRel.getRowType,
+      grouping,
+      getCluster.getTypeFactory.asInstanceOf[FlinkTypeFactory])
+  }
+
+  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
+    new StreamPhysicalLocalGroupAggregate(
+      cluster,
+      traitSet,
+      inputs.get(0),
+      grouping,
+      aggCalls,
+      aggCallNeedRetractions,
+      needRetraction,
+      partialFinalType)
+  }
+
+  override def explainTerms(pw: RelWriter): RelWriter = {
+    val inputRowType = getInput.getRowType
+    super.explainTerms(pw)
+      .itemIf("groupBy", RelExplainUtil.fieldToString(grouping, inputRowType),
+        grouping.nonEmpty)
+      .itemIf("partialFinalType", partialFinalType, partialFinalType != PartialFinalType.NONE)
+      .item("select", RelExplainUtil.streamGroupAggregationToString(
+        inputRowType,
+        getRowType,
+        aggInfoList,
+        grouping,
+        isLocal = true))
+  }
+
+  override def translateToExecNode(): ExecNode[_] = {
+    new StreamExecLocalGroupAggregate(
+      grouping,
+      aggCalls.toArray,
+      aggCallNeedRetractions,
+      needRetraction,
+      ExecEdge.DEFAULT,
+      FlinkTypeFactory.toLogicalRowType(getRowType),
+      getRelDetailedDescription
+    )
+  }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
index a0bb8fd..ce8b563 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
@@ -22,7 +22,7 @@ import org.apache.flink.configuration.ConfigOption
 import org.apache.flink.configuration.ConfigOptions.key
 import org.apache.flink.table.planner.calcite.{FlinkContext, FlinkTypeFactory}
 import org.apache.flink.table.planner.plan.PartialFinalType
-import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecGlobalGroupAggregate, StreamExecIncrementalGroupAggregate, StreamExecLocalGroupAggregate, StreamPhysicalExchange}
+import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecGlobalGroupAggregate, StreamExecIncrementalGroupAggregate, StreamPhysicalLocalGroupAggregate, StreamPhysicalExchange}
 import org.apache.flink.table.planner.plan.utils.{AggregateInfoList, AggregateUtil, DistinctInfo}
 import org.apache.flink.util.Preconditions
 
@@ -34,21 +34,21 @@ import java.util.Collections
 
 /**
   * Rule that matches final [[StreamExecGlobalGroupAggregate]] on [[StreamPhysicalExchange]]
-  * on final [[StreamExecLocalGroupAggregate]] on partial [[StreamExecGlobalGroupAggregate]],
-  * and combines the final [[StreamExecLocalGroupAggregate]] and
+  * on final [[StreamPhysicalLocalGroupAggregate]] on partial [[StreamExecGlobalGroupAggregate]],
+  * and combines the final [[StreamPhysicalLocalGroupAggregate]] and
   * the partial [[StreamExecGlobalGroupAggregate]] into a [[StreamExecIncrementalGroupAggregate]].
   */
 class IncrementalAggregateRule
   extends RelOptRule(
     operand(classOf[StreamExecGlobalGroupAggregate], // final global agg
       operand(classOf[StreamPhysicalExchange], // key by
-        operand(classOf[StreamExecLocalGroupAggregate], // final local agg
+        operand(classOf[StreamPhysicalLocalGroupAggregate], // final local agg
           operand(classOf[StreamExecGlobalGroupAggregate], any())))), // partial global agg
     "IncrementalAggregateRule") {
 
   override def matches(call: RelOptRuleCall): Boolean = {
     val finalGlobalAgg: StreamExecGlobalGroupAggregate = call.rel(0)
-    val finalLocalAgg: StreamExecLocalGroupAggregate = call.rel(2)
+    val finalLocalAgg: StreamPhysicalLocalGroupAggregate = call.rel(2)
     val partialGlobalAgg: StreamExecGlobalGroupAggregate = call.rel(3)
 
     val tableConfig = call.getPlanner.getContext.unwrap(classOf[FlinkContext]).getTableConfig
@@ -66,7 +66,7 @@ class IncrementalAggregateRule
   override def onMatch(call: RelOptRuleCall): Unit = {
     val finalGlobalAgg: StreamExecGlobalGroupAggregate = call.rel(0)
     val exchange: StreamPhysicalExchange = call.rel(1)
-    val finalLocalAgg: StreamExecLocalGroupAggregate = call.rel(2)
+    val finalLocalAgg: StreamPhysicalLocalGroupAggregate = call.rel(2)
     val partialGlobalAgg: StreamExecGlobalGroupAggregate = call.rel(3)
     val aggInputRowType = partialGlobalAgg.inputRowType
 
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
index 7f01e5c..2f804cc 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
@@ -28,9 +28,11 @@ import org.apache.flink.table.planner.plan.rules.physical.FlinkExpandConversionR
 import org.apache.flink.table.planner.plan.utils.{AggregateInfoList, AggregateUtil, ChangelogPlanUtils}
 import org.apache.flink.table.planner.utils.AggregatePhaseStrategy
 import org.apache.flink.table.planner.utils.TableConfigUtils.getAggPhaseStrategy
+
 import org.apache.calcite.plan.RelOptRule.{any, operand}
 import org.apache.calcite.plan.{RelOptRule, RelOptRuleCall}
 import org.apache.calcite.rel.RelNode
+import org.apache.calcite.rel.core.AggregateCall
 
 import java.util
 
@@ -46,7 +48,7 @@ import java.util
   * {{{
   *   StreamExecGlobalGroupAggregate
   *   +- StreamPhysicalExchange
-  *      +- StreamExecLocalGroupAggregate
+  *      +- StreamPhysicalLocalGroupAggregate
   *         +- input of exchange
   * }}}
   */
@@ -97,52 +99,43 @@ class TwoStageOptimizedAggregateRule extends RelOptRule(
       realInput.asInstanceOf[StreamPhysicalRel])
     val fmq = FlinkRelMetadataQuery.reuseOrCreate(call.getMetadataQuery)
     val monotonicity = fmq.getRelModifiedMonotonicity(agg)
-    val needRetractionArray = AggregateUtil.deriveAggCallNeedRetractions(
+    val aggCallNeedRetractions = AggregateUtil.deriveAggCallNeedRetractions(
       agg.grouping.length, agg.aggCalls, needRetraction, monotonicity)
 
-    val localAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
-      FlinkTypeFactory.toLogicalRowType(realInput.getRowType),
-      agg.aggCalls,
-      needRetractionArray,
-      needRetraction,
-      isStateBackendDataViews = false)
-
     val globalAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
       FlinkTypeFactory.toLogicalRowType(realInput.getRowType),
       agg.aggCalls,
-      needRetractionArray,
+      aggCallNeedRetractions,
       needRetraction,
       isStateBackendDataViews = true)
 
-    val globalHashAgg = createTwoStageAgg(realInput, localAggInfoList, globalAggInfoList, agg)
+    val globalHashAgg = createTwoStageAgg(
+      realInput, agg.aggCalls, aggCallNeedRetractions, needRetraction, globalAggInfoList, agg)
     call.transformTo(globalHashAgg)
   }
 
   // the difference between localAggInfos and aggInfos is local agg use heap dataview,
   // but global agg use state dataview
   private def createTwoStageAgg(
-      input: RelNode,
-      localAggInfoList: AggregateInfoList,
+      realInput: RelNode,
+      aggCalls: Seq[AggregateCall],
+      aggCallNeedRetractions: Array[Boolean],
+      needRetraction: Boolean,
       globalAggInfoList: AggregateInfoList,
       agg: StreamPhysicalGroupAggregate): StreamExecGlobalGroupAggregate = {
-    val localAggRowType = AggregateUtil.inferLocalAggRowType(
-      localAggInfoList,
-      input.getRowType,
-      agg.grouping,
-      input.getCluster.getTypeFactory.asInstanceOf[FlinkTypeFactory])
 
     // local agg shouldn't produce insert only messages
-    val localAggTraitSet = input.getTraitSet
+    val localAggTraitSet = realInput.getTraitSet
       .plus(ModifyKindSetTrait.INSERT_ONLY)
       .plus(UpdateKindTrait.NONE)
-    val localHashAgg = new StreamExecLocalGroupAggregate(
+    val localHashAgg = new StreamPhysicalLocalGroupAggregate(
       agg.getCluster,
       localAggTraitSet,
-      input,
-      localAggRowType,
+      realInput,
       agg.grouping,
       agg.aggCalls,
-      localAggInfoList,
+      aggCallNeedRetractions,
+      needRetraction,
       agg.partialFinalType)
 
     // grouping keys is forwarded by local agg, use indices instead of groupings
@@ -153,11 +146,18 @@ class TwoStageOptimizedAggregateRule extends RelOptRule(
       FlinkConventions.STREAM_PHYSICAL, localHashAgg, globalDistribution)
     val globalAggProvidedTraitSet = agg.getTraitSet
 
+    // TODO Temporary solution, remove it later
+    val localAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
+      FlinkTypeFactory.toLogicalRowType(realInput.getRowType),
+      aggCalls,
+      aggCallNeedRetractions,
+      needRetraction,
+      isStateBackendDataViews = false)
     new StreamExecGlobalGroupAggregate(
       agg.getCluster,
       globalAggProvidedTraitSet,
       newInput,
-      input.getRowType,
+      realInput.getRowType,
       agg.getRowType,
       globalGrouping,
       localAggInfoList,
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
index f0e623f..ec2d55c 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
@@ -1019,23 +1019,16 @@ class FlinkRelMdHandlerTestBase {
       aggCallToAggFunction,
       isMerge = false)
 
-    val needRetractionArray = AggregateUtil.deriveAggCallNeedRetractions(
+    val aggCallNeedRetractions = AggregateUtil.deriveAggCallNeedRetractions(
       1, aggCalls, needRetraction = false, null)
-
-    val localAggInfoList = transformToStreamAggregateInfoList(
-      FlinkTypeFactory.toLogicalRowType(studentStreamScan.getRowType),
-      aggCalls,
-      needRetractionArray,
-      needInputCount = false,
-      isStateBackendDataViews = false)
-    val streamLocalAgg = new StreamExecLocalGroupAggregate(
+    val streamLocalAgg = new StreamPhysicalLocalGroupAggregate(
       cluster,
       streamPhysicalTraits,
       studentStreamScan,
-      rowTypeOfLocalAgg,
       Array(3),
       aggCalls,
-      localAggInfoList,
+      aggCallNeedRetractions,
+      false,
       PartialFinalType.NONE)
 
     val streamExchange1 = new StreamPhysicalExchange(
@@ -1043,9 +1036,16 @@ class FlinkRelMdHandlerTestBase {
     val globalAggInfoList = transformToStreamAggregateInfoList(
       FlinkTypeFactory.toLogicalRowType(streamExchange1.getRowType),
       aggCalls,
-      needRetractionArray,
+      aggCallNeedRetractions,
       needInputCount = false,
       isStateBackendDataViews = true)
+    // TODO Temporary solution, remove it later
+    val localAggInfoList = transformToStreamAggregateInfoList(
+      FlinkTypeFactory.toLogicalRowType(studentStreamScan.getRowType),
+      aggCalls,
+      aggCallNeedRetractions,
+      needInputCount = false,
+      isStateBackendDataViews = false)
     val streamGlobalAgg = new StreamExecGlobalGroupAggregate(
       cluster,
       streamPhysicalTraits,

[flink] 02/08: [FLINK-20737][table-planner-blink] Introduce StreamPhysicalGroupAggregate, and make StreamExecGroupAggregate only extended from ExecNode

Posted by go...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 683a2a7af5c248e998c0606ecccbfa2960d847cd
Author: godfreyhe <go...@163.com>
AuthorDate: Thu Dec 24 18:31:58 2020 +0800

    [FLINK-20737][table-planner-blink] Introduce StreamPhysicalGroupAggregate, and make StreamExecGroupAggregate only extended from ExecNode
    
    This closes #14478
---
 .../exec/stream/StreamExecGroupAggregate.java      | 202 +++++++++++++++++++++
 .../plan/metadata/FlinkRelMdColumnInterval.scala   |   6 +-
 .../plan/metadata/FlinkRelMdColumnUniqueness.scala |   2 +-
 .../FlinkRelMdFilteredColumnInterval.scala         |   4 +-
 .../metadata/FlinkRelMdModifiedMonotonicity.scala  |   2 +-
 .../plan/metadata/FlinkRelMdUniqueKeys.scala       |   2 +-
 .../stream/StreamExecGlobalGroupAggregate.scala    |   4 +-
 .../physical/stream/StreamExecGroupAggregate.scala | 192 --------------------
 .../StreamExecIncrementalGroupAggregate.scala      |   4 +-
 .../stream/StreamExecLocalGroupAggregate.scala     |   4 +-
 .../stream/StreamExecPythonGroupAggregate.scala    |   4 +-
 .../stream/StreamPhysicalGroupAggregate.scala      |  97 ++++++++++
 ...cala => StreamPhysicalGroupAggregateBase.scala} |   2 +-
 .../FlinkChangelogModeInferenceProgram.scala       |   4 +-
 .../planner/plan/rules/FlinkStreamRuleSets.scala   |   2 +-
 ...cala => StreamPhysicalGroupAggregateRule.scala} |  19 +-
 .../stream/TwoStageOptimizedAggregateRule.scala    |  14 +-
 .../table/planner/plan/utils/AggregateUtil.scala   |  55 ++++--
 .../plan/metadata/FlinkRelMdHandlerTestBase.scala  |   4 +-
 19 files changed, 376 insertions(+), 247 deletions(-)

diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGroupAggregate.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGroupAggregate.java
new file mode 100644
index 0000000..1331812
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGroupAggregate.java
@@ -0,0 +1,202 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.flink.table.planner.plan.nodes.exec.stream;
+
+import org.apache.flink.api.dag.Transformation;
+import org.apache.flink.streaming.api.operators.KeyedProcessOperator;
+import org.apache.flink.streaming.api.operators.OneInputStreamOperator;
+import org.apache.flink.streaming.api.transformations.OneInputTransformation;
+import org.apache.flink.table.api.TableConfig;
+import org.apache.flink.table.api.config.ExecutionConfigOptions;
+import org.apache.flink.table.data.RowData;
+import org.apache.flink.table.planner.codegen.CodeGeneratorContext;
+import org.apache.flink.table.planner.codegen.EqualiserCodeGenerator;
+import org.apache.flink.table.planner.codegen.agg.AggsHandlerCodeGenerator;
+import org.apache.flink.table.planner.delegation.PlannerBase;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecEdge;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecNode;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeBase;
+import org.apache.flink.table.planner.plan.utils.AggregateInfoList;
+import org.apache.flink.table.planner.plan.utils.AggregateUtil;
+import org.apache.flink.table.planner.plan.utils.KeySelectorUtil;
+import org.apache.flink.table.planner.utils.JavaScalaConversionUtil;
+import org.apache.flink.table.runtime.generated.GeneratedAggsHandleFunction;
+import org.apache.flink.table.runtime.generated.GeneratedRecordEqualiser;
+import org.apache.flink.table.runtime.keyselector.RowDataKeySelector;
+import org.apache.flink.table.runtime.operators.aggregate.GroupAggFunction;
+import org.apache.flink.table.runtime.operators.aggregate.MiniBatchGroupAggFunction;
+import org.apache.flink.table.runtime.operators.bundle.KeyedMapBundleOperator;
+import org.apache.flink.table.runtime.types.LogicalTypeDataTypeConverter;
+import org.apache.flink.table.runtime.typeutils.InternalTypeInfo;
+import org.apache.flink.table.types.logical.LogicalType;
+import org.apache.flink.table.types.logical.RowType;
+import org.apache.flink.util.Preconditions;
+
+import org.apache.calcite.rel.core.AggregateCall;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+/**
+ * Stream {@link ExecNode} for unbounded group aggregate.
+ *
+ * <p>This node does support un-splittable aggregate function (e.g. STDDEV_POP).
+ */
+public class StreamExecGroupAggregate extends ExecNodeBase<RowData>
+        implements StreamExecNode<RowData> {
+    private static final Logger LOG = LoggerFactory.getLogger(StreamExecGroupAggregate.class);
+
+    private final int[] grouping;
+    private final AggregateCall[] aggCalls;
+    /** Each element indicates whether the corresponding agg call needs `retract` method. */
+    private final boolean[] aggCallNeedRetractions;
+    /** Whether this node will generate UPDATE_BEFORE messages. */
+    private final boolean generateUpdateBefore;
+    /** Whether this node consumes retraction messages. */
+    private final boolean needRetraction;
+
+    public StreamExecGroupAggregate(
+            int[] grouping,
+            AggregateCall[] aggCalls,
+            boolean[] aggCallNeedRetractions,
+            boolean generateUpdateBefore,
+            boolean needRetraction,
+            ExecEdge inputEdge,
+            RowType outputType,
+            String description) {
+        super(Collections.singletonList(inputEdge), outputType, description);
+        Preconditions.checkArgument(aggCalls.length == aggCallNeedRetractions.length);
+        this.grouping = grouping;
+        this.aggCalls = aggCalls;
+        this.aggCallNeedRetractions = aggCallNeedRetractions;
+        this.generateUpdateBefore = generateUpdateBefore;
+        this.needRetraction = needRetraction;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected Transformation<RowData> translateToPlanInternal(PlannerBase planner) {
+        final TableConfig tableConfig = planner.getTableConfig();
+        if (grouping.length > 0 && tableConfig.getMinIdleStateRetentionTime() < 0) {
+            LOG.warn(
+                    "No state retention interval configured for a query which accumulates state. "
+                            + "Please provide a query configuration with valid retention interval to prevent excessive "
+                            + "state size. You may specify a retention time of 0 to not clean up the state.");
+        }
+
+        final ExecNode<RowData> inputNode = (ExecNode<RowData>) getInputNodes().get(0);
+        final Transformation<RowData> inputTransform = inputNode.translateToPlan(planner);
+        final RowType inputRowType = (RowType) inputNode.getOutputType();
+
+        final AggsHandlerCodeGenerator generator =
+                new AggsHandlerCodeGenerator(
+                                new CodeGeneratorContext(tableConfig),
+                                planner.getRelBuilder(),
+                                JavaScalaConversionUtil.toScala(inputRowType.getChildren()),
+                                // TODO: heap state backend do not copy key currently,
+                                //  we have to copy input field
+                                // TODO: copy is not need when state backend is rocksdb,
+                                //  improve this in future
+                                // TODO: but other operators do not copy this input field.....
+                                true)
+                        .needAccumulate();
+
+        if (needRetraction) {
+            generator.needRetract();
+        }
+
+        final AggregateInfoList aggInfoList =
+                AggregateUtil.transformToStreamAggregateInfoList(
+                        inputRowType,
+                        JavaScalaConversionUtil.toScala(Arrays.asList(aggCalls)),
+                        aggCallNeedRetractions,
+                        needRetraction,
+                        true,
+                        true);
+        final GeneratedAggsHandleFunction aggsHandler =
+                generator.generateAggsHandler("GroupAggsHandler", aggInfoList);
+
+        final LogicalType[] accTypes =
+                Arrays.stream(aggInfoList.getAccTypes())
+                        .map(LogicalTypeDataTypeConverter::fromDataTypeToLogicalType)
+                        .toArray(LogicalType[]::new);
+        final LogicalType[] aggValueTypes =
+                Arrays.stream(aggInfoList.getActualValueTypes())
+                        .map(LogicalTypeDataTypeConverter::fromDataTypeToLogicalType)
+                        .toArray(LogicalType[]::new);
+        final GeneratedRecordEqualiser recordEqualiser =
+                new EqualiserCodeGenerator(aggValueTypes)
+                        .generateRecordEqualiser("GroupAggValueEqualiser");
+        final int inputCountIndex = aggInfoList.getIndexOfCountStar();
+        final boolean isMiniBatchEnabled =
+                tableConfig
+                        .getConfiguration()
+                        .getBoolean(ExecutionConfigOptions.TABLE_EXEC_MINIBATCH_ENABLED);
+
+        final OneInputStreamOperator<RowData, RowData> operator;
+        if (isMiniBatchEnabled) {
+            MiniBatchGroupAggFunction aggFunction =
+                    new MiniBatchGroupAggFunction(
+                            aggsHandler,
+                            recordEqualiser,
+                            accTypes,
+                            inputRowType,
+                            inputCountIndex,
+                            generateUpdateBefore,
+                            tableConfig.getIdleStateRetention().toMillis());
+            operator =
+                    new KeyedMapBundleOperator<>(
+                            aggFunction, AggregateUtil.createMiniBatchTrigger(tableConfig));
+        } else {
+            GroupAggFunction aggFunction =
+                    new GroupAggFunction(
+                            aggsHandler,
+                            recordEqualiser,
+                            accTypes,
+                            inputCountIndex,
+                            generateUpdateBefore,
+                            tableConfig.getIdleStateRetention().toMillis());
+            operator = new KeyedProcessOperator<>(aggFunction);
+        }
+
+        // partitioned aggregation
+        final OneInputTransformation<RowData, RowData> transform =
+                new OneInputTransformation<>(
+                        inputTransform,
+                        getDesc(),
+                        operator,
+                        InternalTypeInfo.of(getOutputType()),
+                        inputTransform.getParallelism());
+
+        if (inputsContainSingleton()) {
+            transform.setParallelism(1);
+            transform.setMaxParallelism(1);
+        }
+
+        // set KeyType and Selector for state
+        final RowDataKeySelector selector =
+                KeySelectorUtil.getRowDataSelector(grouping, InternalTypeInfo.of(inputRowType));
+        transform.setStateKeySelector(selector);
+        transform.setStateKeyType(selector.getProducedType());
+
+        return transform;
+    }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
index 36251fa..2e33587 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
@@ -433,7 +433,7 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
     * @return interval of the given column on stream group Aggregate
     */
   def getColumnInterval(
-      aggregate: StreamExecGroupAggregate,
+      aggregate: StreamPhysicalGroupAggregate,
       mq: RelMetadataQuery,
       index: Int): ValueInterval = estimateColumnIntervalOfAggregate(aggregate, mq, index)
 
@@ -535,7 +535,7 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
     val input = aggregate.getInput
     val fmq = FlinkRelMetadataQuery.reuseOrCreate(mq)
     val groupSet = aggregate match {
-      case agg: StreamExecGroupAggregate => agg.grouping
+      case agg: StreamPhysicalGroupAggregate => agg.grouping
       case agg: StreamExecLocalGroupAggregate => agg.grouping
       case agg: StreamExecGlobalGroupAggregate => agg.grouping
       case agg: StreamExecIncrementalGroupAggregate => agg.partialAggGrouping
@@ -595,7 +595,7 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
       } else {
         val aggCallIndex = index - groupSet.length
         val aggCall = aggregate match {
-          case agg: StreamExecGroupAggregate if agg.aggCalls.length > aggCallIndex =>
+          case agg: StreamPhysicalGroupAggregate if agg.aggCalls.length > aggCallIndex =>
             agg.aggCalls(aggCallIndex)
           case agg: StreamExecGlobalGroupAggregate
             if agg.globalAggInfoList.getActualAggregateCalls.length > aggCallIndex =>
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala
index ce091ff..5799ab0 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala
@@ -341,7 +341,7 @@ class FlinkRelMdColumnUniqueness private extends MetadataHandler[BuiltInMetadata
   }
 
   def areColumnsUnique(
-      rel: StreamExecGroupAggregate,
+      rel: StreamPhysicalGroupAggregate,
       mq: RelMetadataQuery,
       columns: ImmutableBitSet,
       ignoreNulls: Boolean): JBoolean = {
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
index 11c8383..c851c96 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
@@ -20,7 +20,7 @@ package org.apache.flink.table.planner.plan.metadata
 import org.apache.flink.table.planner.plan.metadata.FlinkMetadata.FilteredColumnInterval
 import org.apache.flink.table.planner.plan.nodes.calcite.TableAggregate
 import org.apache.flink.table.planner.plan.nodes.physical.batch.BatchExecGroupAggregateBase
-import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecGlobalGroupAggregate, StreamExecGroupAggregate, StreamExecGroupTableAggregate, StreamExecGroupWindowAggregate, StreamExecGroupWindowTableAggregate, StreamExecLocalGroupAggregate}
+import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecGlobalGroupAggregate, StreamPhysicalGroupAggregate, StreamExecGroupTableAggregate, StreamExecGroupWindowAggregate, StreamExecGroupWindowTableAggregate, StreamExecLocalGroupAggregate}
 import org.apache.flink.table.planner.plan.stats.ValueInterval
 import org.apache.flink.table.planner.plan.utils.ColumnIntervalUtil
 import org.apache.flink.util.Preconditions.checkArgument
@@ -184,7 +184,7 @@ class FlinkRelMdFilteredColumnInterval private extends MetadataHandler[FilteredC
   }
 
   def getFilteredColumnInterval(
-      aggregate: StreamExecGroupAggregate,
+      aggregate: StreamPhysicalGroupAggregate,
       mq: RelMetadataQuery,
       columnIndex: Int,
       filterArg: Int): ValueInterval = {
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
index a17775b..d46ac17 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
@@ -276,7 +276,7 @@ class FlinkRelMdModifiedMonotonicity private extends MetadataHandler[ModifiedMon
       mq: RelMetadataQuery): RelModifiedMonotonicity = null
 
   def getRelModifiedMonotonicity(
-      rel: StreamExecGroupAggregate,
+      rel: StreamPhysicalGroupAggregate,
       mq: RelMetadataQuery): RelModifiedMonotonicity = {
     getRelModifiedMonotonicityOnAggregate(rel.getInput, mq, rel.aggCalls.toList, rel.grouping)
   }
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala
index ecdf6d1..bf9c1eb 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala
@@ -345,7 +345,7 @@ class FlinkRelMdUniqueKeys private extends MetadataHandler[BuiltInMetadata.Uniqu
   }
 
   def getUniqueKeys(
-      rel: StreamExecGroupAggregate,
+      rel: StreamPhysicalGroupAggregate,
       mq: RelMetadataQuery,
       ignoreNulls: Boolean): JSet[ImmutableBitSet] = {
     getUniqueKeysOnAggregate(rel.grouping, mq, ignoreNulls)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGlobalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGlobalGroupAggregate.scala
index f2842f8..6c44b33 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGlobalGroupAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGlobalGroupAggregate.scala
@@ -46,7 +46,7 @@ import scala.collection.JavaConversions._
 /**
   * Stream physical RelNode for unbounded global group aggregate.
   *
-  * @see [[StreamExecGroupAggregateBase]] for more info.
+  * @see [[StreamPhysicalGroupAggregateBase]] for more info.
   */
 class StreamExecGlobalGroupAggregate(
     cluster: RelOptCluster,
@@ -58,7 +58,7 @@ class StreamExecGlobalGroupAggregate(
     val localAggInfoList: AggregateInfoList,
     val globalAggInfoList: AggregateInfoList,
     val partialFinalType: PartialFinalType)
-  extends StreamExecGroupAggregateBase(cluster, traitSet, inputRel)
+  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel)
   with LegacyStreamExecNode[RowData] {
 
   override def requireWatermark: Boolean = false
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupAggregate.scala
deleted file mode 100644
index f7ae1d2..0000000
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupAggregate.scala
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.flink.table.planner.plan.nodes.physical.stream
-
-import org.apache.flink.api.dag.Transformation
-import org.apache.flink.streaming.api.operators.KeyedProcessOperator
-import org.apache.flink.streaming.api.transformations.OneInputTransformation
-import org.apache.flink.table.api.config.ExecutionConfigOptions
-import org.apache.flink.table.data.RowData
-import org.apache.flink.table.planner.calcite.FlinkTypeFactory
-import org.apache.flink.table.planner.codegen.agg.AggsHandlerCodeGenerator
-import org.apache.flink.table.planner.codegen.{CodeGeneratorContext, EqualiserCodeGenerator}
-import org.apache.flink.table.planner.delegation.StreamPlanner
-import org.apache.flink.table.planner.plan.PartialFinalType
-import org.apache.flink.table.planner.plan.nodes.exec.LegacyStreamExecNode
-import org.apache.flink.table.planner.plan.utils.{AggregateInfoList, AggregateUtil, ChangelogPlanUtils, KeySelectorUtil, RelExplainUtil}
-import org.apache.flink.table.runtime.operators.aggregate.{GroupAggFunction, MiniBatchGroupAggFunction}
-import org.apache.flink.table.runtime.operators.bundle.KeyedMapBundleOperator
-import org.apache.flink.table.runtime.types.LogicalTypeDataTypeConverter.fromDataTypeToLogicalType
-import org.apache.flink.table.runtime.typeutils.InternalTypeInfo
-
-import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
-import org.apache.calcite.rel.`type`.RelDataType
-import org.apache.calcite.rel.core.AggregateCall
-import org.apache.calcite.rel.{RelNode, RelWriter}
-
-import java.util
-
-import scala.collection.JavaConversions._
-
-/**
-  * Stream physical RelNode for unbounded group aggregate.
-  *
-  * This node does support un-splittable aggregate function (e.g. STDDEV_POP).
-  *
-  * @see [[StreamExecGroupAggregateBase]] for more info.
-  */
-class StreamExecGroupAggregate(
-    cluster: RelOptCluster,
-    traitSet: RelTraitSet,
-    inputRel: RelNode,
-    outputRowType: RelDataType,
-    val grouping: Array[Int],
-    val aggCalls: Seq[AggregateCall],
-    var partialFinalType: PartialFinalType = PartialFinalType.NONE)
-  extends StreamExecGroupAggregateBase(cluster, traitSet, inputRel)
-  with LegacyStreamExecNode[RowData] {
-
-  val aggInfoList: AggregateInfoList = AggregateUtil.deriveAggregateInfoList(
-    this,
-    grouping.length,
-    aggCalls)
-
-  override def requireWatermark: Boolean = false
-
-  override def deriveRowType(): RelDataType = outputRowType
-
-  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
-    new StreamExecGroupAggregate(
-      cluster,
-      traitSet,
-      inputs.get(0),
-      outputRowType,
-      grouping,
-      aggCalls,
-      partialFinalType)
-  }
-
-  override def explainTerms(pw: RelWriter): RelWriter = {
-    val inputRowType = getInput.getRowType
-    super.explainTerms(pw)
-      .itemIf("groupBy",
-        RelExplainUtil.fieldToString(grouping, inputRowType), grouping.nonEmpty)
-      .itemIf("partialFinalType", partialFinalType, partialFinalType != PartialFinalType.NONE)
-      .item("select", RelExplainUtil.streamGroupAggregationToString(
-        inputRowType,
-        getRowType,
-        aggInfoList,
-        grouping))
-  }
-
-  //~ ExecNode methods -----------------------------------------------------------
-
-  override protected def translateToPlanInternal(
-      planner: StreamPlanner): Transformation[RowData] = {
-
-    val tableConfig = planner.getTableConfig
-
-    if (grouping.length > 0 && tableConfig.getMinIdleStateRetentionTime < 0) {
-      LOG.warn("No state retention interval configured for a query which accumulates state. " +
-        "Please provide a query configuration with valid retention interval to prevent excessive " +
-        "state size. You may specify a retention time of 0 to not clean up the state.")
-    }
-
-    val inputTransformation = getInputNodes.get(0).translateToPlan(planner)
-      .asInstanceOf[Transformation[RowData]]
-
-    val outRowType = FlinkTypeFactory.toLogicalRowType(outputRowType)
-    val inputRowType = FlinkTypeFactory.toLogicalRowType(getInput.getRowType)
-
-    val generateUpdateBefore = ChangelogPlanUtils.generateUpdateBefore(this)
-    val needRetraction = !ChangelogPlanUtils.inputInsertOnly(this)
-
-    val generator = new AggsHandlerCodeGenerator(
-      CodeGeneratorContext(tableConfig),
-      planner.getRelBuilder,
-      inputRowType.getChildren,
-      // TODO: heap state backend do not copy key currently, we have to copy input field
-      // TODO: copy is not need when state backend is rocksdb, improve this in future
-      // TODO: but other operators do not copy this input field.....
-      copyInputField = true)
-
-    if (needRetraction) {
-      generator.needRetract()
-    }
-
-    val aggsHandler = generator
-      .needAccumulate()
-      .generateAggsHandler("GroupAggsHandler", aggInfoList)
-    val accTypes = aggInfoList.getAccTypes.map(fromDataTypeToLogicalType)
-    val aggValueTypes = aggInfoList.getActualValueTypes.map(fromDataTypeToLogicalType)
-    val recordEqualiser = new EqualiserCodeGenerator(aggValueTypes)
-      .generateRecordEqualiser("GroupAggValueEqualiser")
-    val inputCountIndex = aggInfoList.getIndexOfCountStar
-
-    val isMiniBatchEnabled = tableConfig.getConfiguration.getBoolean(
-      ExecutionConfigOptions.TABLE_EXEC_MINIBATCH_ENABLED)
-
-    val operator = if (isMiniBatchEnabled) {
-      val aggFunction = new MiniBatchGroupAggFunction(
-        aggsHandler,
-        recordEqualiser,
-        accTypes,
-        inputRowType,
-        inputCountIndex,
-        generateUpdateBefore,
-        tableConfig.getIdleStateRetention.toMillis)
-
-      new KeyedMapBundleOperator(
-        aggFunction,
-        AggregateUtil.createMiniBatchTrigger(tableConfig))
-    } else {
-      val aggFunction = new GroupAggFunction(
-        aggsHandler,
-        recordEqualiser,
-        accTypes,
-        inputCountIndex,
-        generateUpdateBefore,
-        tableConfig.getIdleStateRetention.toMillis)
-
-      val operator = new KeyedProcessOperator[RowData, RowData, RowData](aggFunction)
-      operator
-    }
-
-    val selector = KeySelectorUtil.getRowDataSelector(
-      grouping,
-      InternalTypeInfo.of(inputRowType))
-
-    // partitioned aggregation
-    val ret = new OneInputTransformation(
-      inputTransformation,
-      getRelDetailedDescription,
-      operator,
-      InternalTypeInfo.of(outRowType),
-      inputTransformation.getParallelism)
-
-    if (inputsContainSingleton()) {
-      ret.setParallelism(1)
-      ret.setMaxParallelism(1)
-    }
-
-    // set KeyType and Selector for state
-    ret.setStateKeySelector(selector)
-    ret.setStateKeyType(selector.getProducedType)
-    ret
-  }
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
index 9ec2b8d..9706253 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
@@ -67,7 +67,7 @@ import scala.collection.JavaConversions._
   *            +- StreamExecLocalGroupAggregate (partial-local-aggregate)
   * }}}
   *
-  * @see [[StreamExecGroupAggregateBase]] for more info.
+  * @see [[StreamPhysicalGroupAggregateBase]] for more info.
   */
 class StreamExecIncrementalGroupAggregate(
     cluster: RelOptCluster,
@@ -80,7 +80,7 @@ class StreamExecIncrementalGroupAggregate(
     val finalAggCalls: Seq[AggregateCall],
     val finalAggGrouping: Array[Int],
     val partialAggGrouping: Array[Int])
-  extends StreamExecGroupAggregateBase(cluster, traitSet, inputRel)
+  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel)
   with LegacyStreamExecNode[RowData] {
 
   override def deriveRowType(): RelDataType = outputRowType
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecLocalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecLocalGroupAggregate.scala
index f7198bc..730695c 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecLocalGroupAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecLocalGroupAggregate.scala
@@ -44,7 +44,7 @@ import scala.collection.JavaConversions._
 /**
   * Stream physical RelNode for unbounded local group aggregate.
   *
-  * @see [[StreamExecGroupAggregateBase]] for more info.
+  * @see [[StreamPhysicalGroupAggregateBase]] for more info.
   */
 class StreamExecLocalGroupAggregate(
     cluster: RelOptCluster,
@@ -55,7 +55,7 @@ class StreamExecLocalGroupAggregate(
     val aggCalls: Seq[AggregateCall],
     val aggInfoList: AggregateInfoList,
     val partialFinalType: PartialFinalType)
-  extends StreamExecGroupAggregateBase(cluster, traitSet, inputRel)
+  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel)
   with LegacyStreamExecNode[RowData] {
 
   override def requireWatermark: Boolean = false
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupAggregate.scala
index aabf675..3570ca1 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupAggregate.scala
@@ -44,7 +44,7 @@ import java.util
 /**
   * Stream physical RelNode for Python unbounded group aggregate.
   *
-  * @see [[StreamExecGroupAggregateBase]] for more info.
+  * @see [[StreamPhysicalGroupAggregateBase]] for more info.
   */
 class StreamExecPythonGroupAggregate(
     cluster: RelOptCluster,
@@ -53,7 +53,7 @@ class StreamExecPythonGroupAggregate(
     outputRowType: RelDataType,
     val grouping: Array[Int],
     val aggCalls: Seq[AggregateCall])
-  extends StreamExecGroupAggregateBase(cluster, traitSet, inputRel)
+  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel)
   with LegacyStreamExecNode[RowData]
   with CommonPythonAggregate {
 
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupAggregate.scala
new file mode 100644
index 0000000..dcac5ec
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupAggregate.scala
@@ -0,0 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.flink.table.planner.plan.nodes.physical.stream
+
+import org.apache.flink.table.planner.calcite.FlinkTypeFactory
+import org.apache.flink.table.planner.plan.PartialFinalType
+import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecGroupAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.{ExecEdge, ExecNode}
+import org.apache.flink.table.planner.plan.utils.{AggregateUtil, ChangelogPlanUtils, RelExplainUtil}
+
+import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
+import org.apache.calcite.rel.`type`.RelDataType
+import org.apache.calcite.rel.core.AggregateCall
+import org.apache.calcite.rel.{RelNode, RelWriter}
+
+import java.util
+
+/**
+ * Stream physical RelNode for unbounded group aggregate.
+ *
+ * This node does support un-splittable aggregate function (e.g. STDDEV_POP).
+ *
+ * @see [[StreamPhysicalGroupAggregateBase]] for more info.
+ */
+class StreamPhysicalGroupAggregate(
+    cluster: RelOptCluster,
+    traitSet: RelTraitSet,
+    inputRel: RelNode,
+    outputRowType: RelDataType,
+    val grouping: Array[Int],
+    val aggCalls: Seq[AggregateCall],
+    var partialFinalType: PartialFinalType = PartialFinalType.NONE)
+  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel) {
+
+  private val aggInfoList =
+    AggregateUtil.deriveAggregateInfoList(this, grouping.length, aggCalls)
+
+  override def requireWatermark: Boolean = false
+
+  override def deriveRowType(): RelDataType = outputRowType
+
+  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
+    new StreamPhysicalGroupAggregate(
+      cluster,
+      traitSet,
+      inputs.get(0),
+      outputRowType,
+      grouping,
+      aggCalls,
+      partialFinalType)
+  }
+
+  override def explainTerms(pw: RelWriter): RelWriter = {
+    val inputRowType = getInput.getRowType
+    super.explainTerms(pw)
+      .itemIf("groupBy",
+        RelExplainUtil.fieldToString(grouping, inputRowType), grouping.nonEmpty)
+      .itemIf("partialFinalType", partialFinalType, partialFinalType != PartialFinalType.NONE)
+      .item("select", RelExplainUtil.streamGroupAggregationToString(
+        inputRowType,
+        getRowType,
+        aggInfoList,
+        grouping))
+  }
+
+  override def translateToExecNode(): ExecNode[_] = {
+    val aggCallNeedRetractions =
+      AggregateUtil.deriveAggCallNeedRetractions(this, grouping.length, aggCalls)
+    val generateUpdateBefore = ChangelogPlanUtils.generateUpdateBefore(this)
+    val needRetraction = !ChangelogPlanUtils.inputInsertOnly(this)
+    new StreamExecGroupAggregate(
+      grouping,
+      aggCalls.toArray,
+      aggCallNeedRetractions,
+      generateUpdateBefore,
+      needRetraction,
+      ExecEdge.DEFAULT,
+      FlinkTypeFactory.toLogicalRowType(getRowType),
+      getRelDetailedDescription
+    )
+  }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupAggregateBase.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupAggregateBase.scala
similarity index 98%
rename from flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupAggregateBase.scala
rename to flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupAggregateBase.scala
index 7e4ff91..6bbeacc 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupAggregateBase.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupAggregateBase.scala
@@ -44,7 +44,7 @@ import org.apache.calcite.rel.{RelNode, SingleRel}
   *
   * <p>NOTES: partial-aggregation supports local-global mode, so does final-aggregation.
   */
-abstract class StreamExecGroupAggregateBase(
+abstract class StreamPhysicalGroupAggregateBase(
     cluster: RelOptCluster,
     traitSet: RelTraitSet,
     inputRel: RelNode)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
index ab6a76d..8d276ca 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
@@ -164,7 +164,7 @@ class FlinkChangelogModeInferenceProgram extends FlinkOptimizeProgram[StreamOpti
         }
         createNewNode(deduplicate, children, providedTrait, requiredTrait, requester)
 
-      case agg: StreamExecGroupAggregate =>
+      case agg: StreamPhysicalGroupAggregate =>
         // agg support all changes in input
         val children = visitChildren(agg, ModifyKindSetTrait.ALL_CHANGES)
         val inputModifyKindSet = getModifyKindSet(children.head)
@@ -461,7 +461,7 @@ class FlinkChangelogModeInferenceProgram extends FlinkOptimizeProgram[StreamOpti
         }
         visitSink(sink, sinkRequiredTraits)
 
-      case _: StreamExecGroupAggregate | _: StreamExecGroupTableAggregate |
+      case _: StreamPhysicalGroupAggregate | _: StreamExecGroupTableAggregate |
            _: StreamPhysicalLimit | _: StreamExecPythonGroupAggregate |
            _: StreamExecPythonGroupTableAggregate =>
         // Aggregate, TableAggregate and Limit requires update_before if there are updates
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
index 5e83109..d7c695d 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
@@ -420,7 +420,7 @@ object FlinkStreamRuleSets {
     // expand
     StreamPhysicalExpandRule.INSTANCE,
     // group agg
-    StreamExecGroupAggregateRule.INSTANCE,
+    StreamPhysicalGroupAggregateRule.INSTANCE,
     StreamExecGroupTableAggregateRule.INSTANCE,
     StreamExecPythonGroupAggregateRule.INSTANCE,
     StreamExecPythonGroupTableAggregateRule.INSTANCE,
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecGroupAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalGroupAggregateRule.scala
similarity index 88%
rename from flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecGroupAggregateRule.scala
rename to flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalGroupAggregateRule.scala
index c38dc90..b6778f3 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecGroupAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalGroupAggregateRule.scala
@@ -21,9 +21,10 @@ package org.apache.flink.table.planner.plan.rules.physical.stream
 import org.apache.flink.table.api.TableException
 import org.apache.flink.table.planner.plan.`trait`.FlinkRelDistribution
 import org.apache.flink.table.planner.plan.nodes.FlinkConventions
-import org.apache.flink.table.planner.plan.utils.PythonUtil.isPythonAggregate
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalAggregate
-import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamExecGroupAggregate
+import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamPhysicalGroupAggregate
+import org.apache.flink.table.planner.plan.utils.PythonUtil.isPythonAggregate
+
 import org.apache.calcite.plan.{RelOptRule, RelOptRuleCall}
 import org.apache.calcite.rel.RelNode
 import org.apache.calcite.rel.convert.ConverterRule
@@ -32,14 +33,14 @@ import org.apache.calcite.rel.core.Aggregate.Group
 import scala.collection.JavaConversions._
 
 /**
-  * Rule to convert a [[FlinkLogicalAggregate]] into a [[StreamExecGroupAggregate]].
-  */
-class StreamExecGroupAggregateRule
+ * Rule to convert a [[FlinkLogicalAggregate]] into a [[StreamPhysicalGroupAggregate]].
+ */
+class StreamPhysicalGroupAggregateRule
   extends ConverterRule(
     classOf[FlinkLogicalAggregate],
     FlinkConventions.LOGICAL,
     FlinkConventions.STREAM_PHYSICAL,
-    "StreamExecGroupAggregateRule") {
+    "StreamPhysicalGroupAggregateRule") {
 
   override def matches(call: RelOptRuleCall): Boolean = {
     val agg: FlinkLogicalAggregate = call.rel(0)
@@ -65,7 +66,7 @@ class StreamExecGroupAggregateRule
     val providedTraitSet = rel.getTraitSet.replace(FlinkConventions.STREAM_PHYSICAL)
     val newInput: RelNode = RelOptRule.convert(agg.getInput, requiredTraitSet)
 
-    new StreamExecGroupAggregate(
+    new StreamPhysicalGroupAggregate(
       rel.getCluster,
       providedTraitSet,
       newInput,
@@ -76,6 +77,6 @@ class StreamExecGroupAggregateRule
   }
 }
 
-object StreamExecGroupAggregateRule {
-  val INSTANCE: RelOptRule = new StreamExecGroupAggregateRule
+object StreamPhysicalGroupAggregateRule {
+  val INSTANCE: RelOptRule = new StreamPhysicalGroupAggregateRule
 }
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
index afb24fb..7f01e5c 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
@@ -35,7 +35,7 @@ import org.apache.calcite.rel.RelNode
 import java.util
 
 /**
-  * Rule that matches [[StreamExecGroupAggregate]] on [[StreamPhysicalExchange]]
+  * Rule that matches [[StreamPhysicalGroupAggregate]] on [[StreamPhysicalExchange]]
   * with the following condition:
   * 1. mini-batch is enabled in given TableConfig,
   * 2. two-phase aggregation is enabled in given TableConfig,
@@ -51,21 +51,21 @@ import java.util
   * }}}
   */
 class TwoStageOptimizedAggregateRule extends RelOptRule(
-  operand(classOf[StreamExecGroupAggregate],
+  operand(classOf[StreamPhysicalGroupAggregate],
     operand(classOf[StreamPhysicalExchange],
       operand(classOf[RelNode], any))),
   "TwoStageOptimizedAggregateRule") {
 
   override def matches(call: RelOptRuleCall): Boolean = {
     val tableConfig = call.getPlanner.getContext.unwrap(classOf[FlinkContext]).getTableConfig
-    val agg: StreamExecGroupAggregate = call.rel(0)
+    val agg: StreamPhysicalGroupAggregate = call.rel(0)
     val realInput: RelNode = call.rel(2)
 
     val needRetraction = !ChangelogPlanUtils.isInsertOnly(
       realInput.asInstanceOf[StreamPhysicalRel])
     val fmq = FlinkRelMetadataQuery.reuseOrCreate(call.getMetadataQuery)
     val monotonicity = fmq.getRelModifiedMonotonicity(agg)
-    val needRetractionArray = AggregateUtil.getNeedRetractions(
+    val needRetractionArray = AggregateUtil.deriveAggCallNeedRetractions(
       agg.grouping.length, agg.aggCalls, needRetraction, monotonicity)
 
     val aggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
@@ -91,13 +91,13 @@ class TwoStageOptimizedAggregateRule extends RelOptRule(
   }
 
   override def onMatch(call: RelOptRuleCall): Unit = {
-    val agg: StreamExecGroupAggregate = call.rel(0)
+    val agg: StreamPhysicalGroupAggregate = call.rel(0)
     val realInput: RelNode = call.rel(2)
     val needRetraction = !ChangelogPlanUtils.isInsertOnly(
       realInput.asInstanceOf[StreamPhysicalRel])
     val fmq = FlinkRelMetadataQuery.reuseOrCreate(call.getMetadataQuery)
     val monotonicity = fmq.getRelModifiedMonotonicity(agg)
-    val needRetractionArray = AggregateUtil.getNeedRetractions(
+    val needRetractionArray = AggregateUtil.deriveAggCallNeedRetractions(
       agg.grouping.length, agg.aggCalls, needRetraction, monotonicity)
 
     val localAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
@@ -124,7 +124,7 @@ class TwoStageOptimizedAggregateRule extends RelOptRule(
       input: RelNode,
       localAggInfoList: AggregateInfoList,
       globalAggInfoList: AggregateInfoList,
-      agg: StreamExecGroupAggregate): StreamExecGlobalGroupAggregate = {
+      agg: StreamPhysicalGroupAggregate): StreamExecGlobalGroupAggregate = {
     val localAggRowType = AggregateUtil.inferLocalAggRowType(
       localAggInfoList,
       input.getRowType,
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala
index 01fd4d4..ea1205b 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/utils/AggregateUtil.scala
@@ -180,22 +180,13 @@ object AggregateUtil extends Enumeration {
       groupCount: Int,
       aggCalls: Seq[AggregateCall]): AggregateInfoList = {
     val input = agg.getInput(0)
-    // need to call `retract()` if input contains update or delete
-    val modifyKindSetTrait = input.getTraitSet.getTrait(ModifyKindSetTraitDef.INSTANCE)
-    val needRetraction = if (modifyKindSetTrait == null) {
-      // FlinkChangelogModeInferenceProgram is not applied yet, false as default
-      false
-    } else {
-      !modifyKindSetTrait.modifyKindSet.isInsertOnly
-    }
-    val fmq = FlinkRelMetadataQuery.reuseOrCreate(agg.getCluster.getMetadataQuery)
-    val monotonicity = fmq.getRelModifiedMonotonicity(agg)
-    val needRetractionArray = getNeedRetractions(groupCount, aggCalls, needRetraction, monotonicity)
+    val aggCallNeedRetractions = deriveAggCallNeedRetractions(agg, groupCount, aggCalls)
+    val needInputCount = needRetraction(agg)
     transformToStreamAggregateInfoList(
       FlinkTypeFactory.toLogicalRowType(input.getRowType),
       aggCalls,
-      needRetractionArray,
-      needInputCount = needRetraction,
+      aggCallNeedRetractions,
+      needInputCount,
       isStateBackendDataViews = true)
   }
 
@@ -782,10 +773,40 @@ object AggregateUtil extends Enumeration {
   }
 
   /**
-    * Optimize max or min with retraction agg. MaxWithRetract can be optimized to Max if input is
-    * update increasing.
-    */
-  def getNeedRetractions(
+   * Return true if the given agg rel needs retraction message, else false.
+   */
+  def needRetraction(agg: StreamPhysicalRel): Boolean = {
+    // need to call `retract()` if input contains update or delete
+    val modifyKindSetTrait = agg.getInput(0).getTraitSet.getTrait(ModifyKindSetTraitDef.INSTANCE)
+    if (modifyKindSetTrait == null) {
+      // FlinkChangelogModeInferenceProgram is not applied yet, false as default
+      false
+    } else {
+      !modifyKindSetTrait.modifyKindSet.isInsertOnly
+    }
+  }
+
+  /**
+   * Return the retraction flags for each given agg calls, currently MAX and MIN are supported.
+   * MaxWithRetract can be optimized to Max if input is update increasing,
+   * MinWithRetract can be optimized to Min if input is update decreasing.
+   */
+  def deriveAggCallNeedRetractions(
+      agg: StreamPhysicalRel,
+      groupCount: Int,
+      aggCalls: Seq[AggregateCall]): Array[Boolean] = {
+    val fmq = FlinkRelMetadataQuery.reuseOrCreate(agg.getCluster.getMetadataQuery)
+    val monotonicity = fmq.getRelModifiedMonotonicity(agg)
+    val needRetractionFlag = needRetraction(agg)
+    deriveAggCallNeedRetractions(groupCount, aggCalls, needRetractionFlag, monotonicity)
+  }
+
+  /**
+   * Return the retraction flags for each given agg calls, currently max and min are supported.
+   * MaxWithRetract can be optimized to Max if input is update increasing,
+   * MinWithRetract can be optimized to Min if input is update decreasing.
+   */
+  def deriveAggCallNeedRetractions(
       groupCount: Int,
       aggCalls: Seq[AggregateCall],
       needRetraction: Boolean,
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
index eaa38bf..f0e623f 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
@@ -1019,7 +1019,7 @@ class FlinkRelMdHandlerTestBase {
       aggCallToAggFunction,
       isMerge = false)
 
-    val needRetractionArray = AggregateUtil.getNeedRetractions(
+    val needRetractionArray = AggregateUtil.deriveAggCallNeedRetractions(
       1, aggCalls, needRetraction = false, null)
 
     val localAggInfoList = transformToStreamAggregateInfoList(
@@ -1059,7 +1059,7 @@ class FlinkRelMdHandlerTestBase {
 
     val streamExchange2 = new StreamPhysicalExchange(cluster,
       studentStreamScan.getTraitSet.replace(hash3), studentStreamScan, hash3)
-    val streamGlobalAggWithoutLocal = new StreamExecGroupAggregate(
+    val streamGlobalAggWithoutLocal = new StreamPhysicalGroupAggregate(
       cluster,
       streamPhysicalTraits,
       streamExchange2,

[flink] 07/08: [FLINK-20737][table-planner-blink] Introduce StreamPhysicalGroupTableAggregate, and make StreamExecGroupTableAggregate only extended from ExecNode

Posted by go...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit c96d1fffc0bd3bfb519e24e038c348053201f8a2
Author: godfreyhe <go...@163.com>
AuthorDate: Wed Dec 23 19:33:21 2020 +0800

    [FLINK-20737][table-planner-blink] Introduce StreamPhysicalGroupTableAggregate, and make StreamExecGroupTableAggregate only extended from ExecNode
    
    This closes #14478
---
 .../exec/stream/StreamExecGroupTableAggregate.java | 166 +++++++++++++++++++++
 .../plan/metadata/FlinkRelMdColumnInterval.scala   |   4 +-
 .../FlinkRelMdFilteredColumnInterval.scala         |   4 +-
 .../metadata/FlinkRelMdModifiedMonotonicity.scala  |   2 +-
 .../stream/StreamExecGroupTableAggregate.scala     | 140 -----------------
 .../StreamExecPythonGroupTableAggregate.scala      |   4 +-
 .../stream/StreamPhysicalGroupTableAggregate.scala |  76 ++++++++++
 ...=> StreamPhysicalGroupTableAggregateBase.scala} |   9 +-
 .../FlinkChangelogModeInferenceProgram.scala       |   4 +-
 .../planner/plan/rules/FlinkStreamRuleSets.scala   |   2 +-
 ...=> StreamPhysicalGroupTableAggregateRule.scala} |  23 +--
 .../plan/metadata/FlinkRelMdHandlerTestBase.scala  |   4 +-
 12 files changed, 271 insertions(+), 167 deletions(-)

diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGroupTableAggregate.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGroupTableAggregate.java
new file mode 100644
index 0000000..e81c6da
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGroupTableAggregate.java
@@ -0,0 +1,166 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.flink.table.planner.plan.nodes.exec.stream;
+
+import org.apache.flink.api.dag.Transformation;
+import org.apache.flink.streaming.api.operators.KeyedProcessOperator;
+import org.apache.flink.streaming.api.operators.OneInputStreamOperator;
+import org.apache.flink.streaming.api.transformations.OneInputTransformation;
+import org.apache.flink.table.api.TableConfig;
+import org.apache.flink.table.data.RowData;
+import org.apache.flink.table.planner.codegen.CodeGeneratorContext;
+import org.apache.flink.table.planner.codegen.agg.AggsHandlerCodeGenerator;
+import org.apache.flink.table.planner.delegation.PlannerBase;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecEdge;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecNode;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeBase;
+import org.apache.flink.table.planner.plan.utils.AggregateInfoList;
+import org.apache.flink.table.planner.plan.utils.AggregateUtil;
+import org.apache.flink.table.planner.plan.utils.KeySelectorUtil;
+import org.apache.flink.table.planner.utils.JavaScalaConversionUtil;
+import org.apache.flink.table.runtime.generated.GeneratedTableAggsHandleFunction;
+import org.apache.flink.table.runtime.keyselector.RowDataKeySelector;
+import org.apache.flink.table.runtime.operators.aggregate.GroupTableAggFunction;
+import org.apache.flink.table.runtime.types.LogicalTypeDataTypeConverter;
+import org.apache.flink.table.runtime.typeutils.InternalTypeInfo;
+import org.apache.flink.table.types.logical.LogicalType;
+import org.apache.flink.table.types.logical.RowType;
+import org.apache.flink.util.Preconditions;
+
+import org.apache.calcite.rel.core.AggregateCall;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+/** Stream {@link ExecNode} for unbounded java/scala group table aggregate. */
+public class StreamExecGroupTableAggregate extends ExecNodeBase<RowData>
+        implements StreamExecNode<RowData> {
+    private static final Logger LOG = LoggerFactory.getLogger(StreamExecGroupTableAggregate.class);
+
+    private final int[] grouping;
+    private final AggregateCall[] aggCalls;
+    /** Each element indicates whether the corresponding agg call needs `retract` method. */
+    private final boolean[] aggCallNeedRetractions;
+    /** Whether this node will generate UPDATE_BEFORE messages. */
+    private final boolean generateUpdateBefore;
+    /** Whether this node consumes retraction messages. */
+    private final boolean needRetraction;
+
+    public StreamExecGroupTableAggregate(
+            int[] grouping,
+            AggregateCall[] aggCalls,
+            boolean[] aggCallNeedRetractions,
+            boolean generateUpdateBefore,
+            boolean needRetraction,
+            ExecEdge inputEdge,
+            RowType outputType,
+            String description) {
+        super(Collections.singletonList(inputEdge), outputType, description);
+        Preconditions.checkArgument(aggCalls.length == aggCallNeedRetractions.length);
+        this.grouping = grouping;
+        this.aggCalls = aggCalls;
+        this.aggCallNeedRetractions = aggCallNeedRetractions;
+        this.generateUpdateBefore = generateUpdateBefore;
+        this.needRetraction = needRetraction;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected Transformation<RowData> translateToPlanInternal(PlannerBase planner) {
+        final TableConfig tableConfig = planner.getTableConfig();
+
+        if (grouping.length > 0 && tableConfig.getMinIdleStateRetentionTime() < 0) {
+            LOG.warn(
+                    "No state retention interval configured for a query which accumulates state. "
+                            + "Please provide a query configuration with valid retention interval to prevent excessive "
+                            + "state size. You may specify a retention time of 0 to not clean up the state.");
+        }
+
+        final ExecNode<RowData> inputNode = (ExecNode<RowData>) getInputNodes().get(0);
+        final Transformation<RowData> inputTransform = inputNode.translateToPlan(planner);
+        final RowType inputRowType = (RowType) inputNode.getOutputType();
+
+        final AggsHandlerCodeGenerator generator =
+                new AggsHandlerCodeGenerator(
+                                new CodeGeneratorContext(tableConfig),
+                                planner.getRelBuilder(),
+                                JavaScalaConversionUtil.toScala(inputRowType.getChildren()),
+                                // TODO: heap state backend do not copy key currently,
+                                //  we have to copy input field
+                                // TODO: copy is not need when state backend is rocksdb,
+                                //  improve this in future
+                                // TODO: but other operators do not copy this input field.....
+                                true)
+                        .needAccumulate();
+
+        if (needRetraction) {
+            generator.needRetract();
+        }
+
+        final AggregateInfoList aggInfoList =
+                AggregateUtil.transformToStreamAggregateInfoList(
+                        inputRowType,
+                        JavaScalaConversionUtil.toScala(Arrays.asList(aggCalls)),
+                        aggCallNeedRetractions,
+                        needRetraction,
+                        true,
+                        true);
+        final GeneratedTableAggsHandleFunction aggsHandler =
+                generator.generateTableAggsHandler("GroupTableAggHandler", aggInfoList);
+
+        final LogicalType[] accTypes =
+                Arrays.stream(aggInfoList.getAccTypes())
+                        .map(LogicalTypeDataTypeConverter::fromDataTypeToLogicalType)
+                        .toArray(LogicalType[]::new);
+        final int inputCountIndex = aggInfoList.getIndexOfCountStar();
+        final GroupTableAggFunction aggFunction =
+                new GroupTableAggFunction(
+                        aggsHandler,
+                        accTypes,
+                        inputCountIndex,
+                        generateUpdateBefore,
+                        tableConfig.getIdleStateRetention().toMillis());
+        final OneInputStreamOperator<RowData, RowData> operator =
+                new KeyedProcessOperator<>(aggFunction);
+
+        // partitioned aggregation
+        final OneInputTransformation<RowData, RowData> transform =
+                new OneInputTransformation<>(
+                        inputTransform,
+                        "GroupTableAggregate",
+                        operator,
+                        InternalTypeInfo.of(getOutputType()),
+                        inputTransform.getParallelism());
+
+        if (inputsContainSingleton()) {
+            transform.setParallelism(1);
+            transform.setMaxParallelism(1);
+        }
+
+        // set KeyType and Selector for state
+        final RowDataKeySelector selector =
+                KeySelectorUtil.getRowDataSelector(grouping, InternalTypeInfo.of(inputRowType));
+        transform.setStateKeySelector(selector);
+        transform.setStateKeyType(selector.getProducedType());
+
+        return transform;
+    }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
index 10ec872..3bb4139 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
@@ -446,7 +446,7 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
     * @return interval of the given column on stream group TableAggregate
     */
   def getColumnInterval(
-    aggregate: StreamExecGroupTableAggregate,
+    aggregate: StreamPhysicalGroupTableAggregate,
     mq: RelMetadataQuery,
     index: Int): ValueInterval = estimateColumnIntervalOfAggregate(aggregate, mq, index)
 
@@ -550,7 +550,7 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
         agg.getGrouping ++ Array(agg.inputTimeFieldIndex) ++ agg.getAuxGrouping
       case agg: BatchExecWindowAggregateBase => agg.getGrouping ++ agg.getAuxGrouping
       case agg: TableAggregate => agg.getGroupSet.toArray
-      case agg: StreamExecGroupTableAggregate => agg.grouping
+      case agg: StreamPhysicalGroupTableAggregate => agg.grouping
       case agg: StreamExecGroupWindowTableAggregate => agg.getGrouping
     }
 
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
index f8c6646..b3821cb 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
@@ -20,7 +20,7 @@ package org.apache.flink.table.planner.plan.metadata
 import org.apache.flink.table.planner.plan.metadata.FlinkMetadata.FilteredColumnInterval
 import org.apache.flink.table.planner.plan.nodes.calcite.TableAggregate
 import org.apache.flink.table.planner.plan.nodes.physical.batch.BatchExecGroupAggregateBase
-import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecGroupTableAggregate, StreamExecGroupWindowAggregate, StreamExecGroupWindowTableAggregate, StreamPhysicalGlobalGroupAggregate, StreamPhysicalGroupAggregate, StreamPhysicalLocalGroupAggregate}
+import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecGroupWindowAggregate, StreamExecGroupWindowTableAggregate, StreamPhysicalGlobalGroupAggregate, StreamPhysicalGroupAggregate, StreamPhysicalGroupTableAggregate, StreamPhysicalLocalGroupAggregate}
 import org.apache.flink.table.planner.plan.stats.ValueInterval
 import org.apache.flink.table.planner.plan.utils.ColumnIntervalUtil
 import org.apache.flink.util.Preconditions.checkArgument
@@ -192,7 +192,7 @@ class FlinkRelMdFilteredColumnInterval private extends MetadataHandler[FilteredC
   }
 
   def getFilteredColumnInterval(
-    aggregate: StreamExecGroupTableAggregate,
+    aggregate: StreamPhysicalGroupTableAggregate,
     mq: RelMetadataQuery,
     columnIndex: Int,
     filterArg: Int): ValueInterval = {
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
index 9b0932a..7f128ec 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
@@ -282,7 +282,7 @@ class FlinkRelMdModifiedMonotonicity private extends MetadataHandler[ModifiedMon
   }
 
   def getRelModifiedMonotonicity(
-      rel: StreamExecGroupTableAggregate,
+      rel: StreamPhysicalGroupTableAggregate,
       mq: RelMetadataQuery): RelModifiedMonotonicity = {
     getRelModifiedMonotonicityOnTableAggregate(
       rel.getInput, rel.grouping, rel.getRowType.getFieldCount, mq)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupTableAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupTableAggregate.scala
deleted file mode 100644
index ef0a556..0000000
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupTableAggregate.scala
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.flink.table.planner.plan.nodes.physical.stream
-
-import org.apache.flink.api.dag.Transformation
-import org.apache.flink.streaming.api.operators.KeyedProcessOperator
-import org.apache.flink.streaming.api.transformations.OneInputTransformation
-import org.apache.flink.table.data.RowData
-import org.apache.flink.table.planner.calcite.FlinkTypeFactory
-import org.apache.flink.table.planner.codegen.CodeGeneratorContext
-import org.apache.flink.table.planner.codegen.agg.AggsHandlerCodeGenerator
-import org.apache.flink.table.planner.delegation.StreamPlanner
-import org.apache.flink.table.planner.plan.utils._
-import org.apache.flink.table.runtime.operators.aggregate.GroupTableAggFunction
-import org.apache.flink.table.runtime.types.LogicalTypeDataTypeConverter.fromDataTypeToLogicalType
-import org.apache.flink.table.runtime.typeutils.InternalTypeInfo
-
-import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
-import org.apache.calcite.rel.`type`.RelDataType
-import org.apache.calcite.rel.core.AggregateCall
-import org.apache.calcite.rel.RelNode
-
-import java.util
-
-import scala.collection.JavaConversions._
-
-/**
-  * Stream physical RelNode for unbounded java/scala group table aggregate.
-  */
-class StreamExecGroupTableAggregate(
-    cluster: RelOptCluster,
-    traitSet: RelTraitSet,
-    inputRel: RelNode,
-    outputRowType: RelDataType,
-    grouping: Array[Int],
-    aggCalls: Seq[AggregateCall])
-  extends StreamExecGroupTableAggregateBase(
-    cluster,
-    traitSet,
-    inputRel,
-    outputRowType,
-    grouping,
-    aggCalls) {
-
-  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
-    new StreamExecGroupTableAggregate(
-      cluster,
-      traitSet,
-      inputs.get(0),
-      outputRowType,
-      grouping,
-      aggCalls)
-  }
-
-  override protected def translateToPlanInternal(
-      planner: StreamPlanner): Transformation[RowData] = {
-
-    val tableConfig = planner.getTableConfig
-
-    if (grouping.length > 0 && tableConfig.getMinIdleStateRetentionTime < 0) {
-      LOG.warn("No state retention interval configured for a query which accumulates state. " +
-        "Please provide a query configuration with valid retention interval to prevent excessive " +
-        "state size. You may specify a retention time of 0 to not clean up the state.")
-    }
-
-    val inputTransformation = getInputNodes.get(0).translateToPlan(planner)
-      .asInstanceOf[Transformation[RowData]]
-
-    val outRowType = FlinkTypeFactory.toLogicalRowType(outputRowType)
-    val inputRowType = FlinkTypeFactory.toLogicalRowType(getInput.getRowType)
-
-    val generateUpdateBefore = ChangelogPlanUtils.generateUpdateBefore(this)
-    val needRetraction = !ChangelogPlanUtils.inputInsertOnly(this)
-
-    val generator = new AggsHandlerCodeGenerator(
-      CodeGeneratorContext(tableConfig),
-      planner.getRelBuilder,
-      inputRowType.getChildren,
-      // TODO: heap state backend do not copy key currently, we have to copy input field
-      // TODO: copy is not need when state backend is rocksdb, improve this in future
-      // TODO: but other operators do not copy this input field.....
-      copyInputField = true)
-
-    if (needRetraction) {
-      generator.needRetract()
-    }
-
-    val aggsHandler = generator
-      .needAccumulate()
-      .generateTableAggsHandler("GroupTableAggHandler", aggInfoList)
-
-    val accTypes = aggInfoList.getAccTypes.map(fromDataTypeToLogicalType)
-    val inputCountIndex = aggInfoList.getIndexOfCountStar
-
-    val aggFunction = new GroupTableAggFunction(
-      aggsHandler,
-      accTypes,
-      inputCountIndex,
-      generateUpdateBefore,
-      tableConfig.getIdleStateRetention.toMillis)
-    val operator = new KeyedProcessOperator[RowData, RowData, RowData](aggFunction)
-
-    val selector = KeySelectorUtil.getRowDataSelector(
-      grouping,
-      InternalTypeInfo.of(inputRowType))
-
-    // partitioned aggregation
-    val ret = new OneInputTransformation(
-      inputTransformation,
-      "GroupTableAggregate",
-      operator,
-      InternalTypeInfo.of(outRowType),
-      inputTransformation.getParallelism)
-
-    if (inputsContainSingleton()) {
-      ret.setParallelism(1)
-      ret.setMaxParallelism(1)
-    }
-
-    // set KeyType and Selector for state
-    ret.setStateKeySelector(selector)
-    ret.setStateKeyType(selector.getProducedType)
-    ret
-  }
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupTableAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupTableAggregate.scala
index cab5a46..1251043 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupTableAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecPythonGroupTableAggregate.scala
@@ -26,6 +26,7 @@ import org.apache.flink.table.data.RowData
 import org.apache.flink.table.functions.python.PythonAggregateFunctionInfo
 import org.apache.flink.table.planner.calcite.FlinkTypeFactory
 import org.apache.flink.table.planner.delegation.StreamPlanner
+import org.apache.flink.table.planner.plan.nodes.exec.LegacyStreamExecNode
 import org.apache.flink.table.planner.plan.nodes.exec.common.CommonExecPythonAggregate
 import org.apache.flink.table.planner.plan.utils.{ChangelogPlanUtils, KeySelectorUtil}
 import org.apache.flink.table.planner.typeutils.DataViewUtils.DataViewSpec
@@ -49,13 +50,14 @@ class StreamExecPythonGroupTableAggregate(
     outputRowType: RelDataType,
     grouping: Array[Int],
     aggCalls: Seq[AggregateCall])
-  extends StreamExecGroupTableAggregateBase(
+  extends StreamPhysicalGroupTableAggregateBase(
     cluster,
     traitSet,
     inputRel,
     outputRowType,
     grouping,
     aggCalls)
+  with LegacyStreamExecNode[RowData]
   with CommonExecPythonAggregate {
 
   override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupTableAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupTableAggregate.scala
new file mode 100644
index 0000000..dd48117
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupTableAggregate.scala
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.flink.table.planner.plan.nodes.physical.stream
+
+import org.apache.flink.table.planner.calcite.FlinkTypeFactory
+import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecGroupTableAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.{ExecEdge, ExecNode}
+import org.apache.flink.table.planner.plan.utils.{AggregateUtil, ChangelogPlanUtils}
+
+import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
+import org.apache.calcite.rel.RelNode
+import org.apache.calcite.rel.`type`.RelDataType
+import org.apache.calcite.rel.core.AggregateCall
+
+import java.util
+
+/**
+ * Stream physical RelNode for unbounded java/scala group table aggregate.
+ */
+class StreamPhysicalGroupTableAggregate(
+    cluster: RelOptCluster,
+    traitSet: RelTraitSet,
+    inputRel: RelNode,
+    outputRowType: RelDataType,
+    grouping: Array[Int],
+    aggCalls: Seq[AggregateCall])
+  extends StreamPhysicalGroupTableAggregateBase(
+    cluster,
+    traitSet,
+    inputRel,
+    outputRowType,
+    grouping,
+    aggCalls) {
+
+  override def copy(traitSet: RelTraitSet, inputs: util.List[RelNode]): RelNode = {
+    new StreamPhysicalGroupTableAggregate(
+      cluster,
+      traitSet,
+      inputs.get(0),
+      outputRowType,
+      grouping,
+      aggCalls)
+  }
+
+  override def translateToExecNode(): ExecNode[_] = {
+    val aggCallNeedRetractions =
+      AggregateUtil.deriveAggCallNeedRetractions(this, grouping.length, aggCalls)
+    val generateUpdateBefore = ChangelogPlanUtils.generateUpdateBefore(this)
+    val needRetraction = !ChangelogPlanUtils.inputInsertOnly(this)
+    new StreamExecGroupTableAggregate(
+      grouping,
+      aggCalls.toArray,
+      aggCallNeedRetractions,
+      generateUpdateBefore,
+      needRetraction,
+      ExecEdge.DEFAULT,
+      FlinkTypeFactory.toLogicalRowType(getRowType),
+      getRelDetailedDescription
+    )
+  }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupTableAggregateBase.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupTableAggregateBase.scala
similarity index 86%
rename from flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupTableAggregateBase.scala
rename to flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupTableAggregateBase.scala
index c7c8a9b..ff2d627 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGroupTableAggregateBase.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGroupTableAggregateBase.scala
@@ -17,8 +17,6 @@
  */
 package org.apache.flink.table.planner.plan.nodes.physical.stream
 
-import org.apache.flink.table.data.RowData
-import org.apache.flink.table.planner.plan.nodes.exec.LegacyStreamExecNode
 import org.apache.flink.table.planner.plan.utils._
 
 import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
@@ -29,7 +27,7 @@ import org.apache.calcite.rel.{RelNode, RelWriter, SingleRel}
 /**
   * Base Stream physical RelNode for unbounded group table aggregate.
   */
-abstract class StreamExecGroupTableAggregateBase(
+abstract class StreamPhysicalGroupTableAggregateBase(
     cluster: RelOptCluster,
     traitSet: RelTraitSet,
     inputRel: RelNode,
@@ -37,10 +35,9 @@ abstract class StreamExecGroupTableAggregateBase(
     val grouping: Array[Int],
     val aggCalls: Seq[AggregateCall])
   extends SingleRel(cluster, traitSet, inputRel)
-  with StreamPhysicalRel
-  with LegacyStreamExecNode[RowData] {
+  with StreamPhysicalRel {
 
-  val aggInfoList: AggregateInfoList = AggregateUtil.deriveAggregateInfoList(
+  protected val aggInfoList: AggregateInfoList = AggregateUtil.deriveAggregateInfoList(
     this,
     grouping.length,
     aggCalls)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
index 2e862e1..b7723fa 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/optimize/program/FlinkChangelogModeInferenceProgram.scala
@@ -178,7 +178,7 @@ class FlinkChangelogModeInferenceProgram extends FlinkOptimizeProgram[StreamOpti
         val providedTrait = new ModifyKindSetTrait(builder.build())
         createNewNode(agg, children, providedTrait, requiredTrait, requester)
 
-      case tagg: StreamExecGroupTableAggregateBase =>
+      case tagg: StreamPhysicalGroupTableAggregateBase =>
         // table agg support all changes in input
         val children = visitChildren(tagg, ModifyKindSetTrait.ALL_CHANGES)
         // table aggregate will produce all changes, including deletions
@@ -461,7 +461,7 @@ class FlinkChangelogModeInferenceProgram extends FlinkOptimizeProgram[StreamOpti
         }
         visitSink(sink, sinkRequiredTraits)
 
-      case _: StreamPhysicalGroupAggregate | _: StreamExecGroupTableAggregate |
+      case _: StreamPhysicalGroupAggregate | _: StreamPhysicalGroupTableAggregate |
            _: StreamPhysicalLimit | _: StreamPhysicalPythonGroupAggregate |
            _: StreamExecPythonGroupTableAggregate =>
         // Aggregate, TableAggregate and Limit requires update_before if there are updates
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
index 4fc6e04..d658e71 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/FlinkStreamRuleSets.scala
@@ -421,7 +421,7 @@ object FlinkStreamRuleSets {
     StreamPhysicalExpandRule.INSTANCE,
     // group agg
     StreamPhysicalGroupAggregateRule.INSTANCE,
-    StreamExecGroupTableAggregateRule.INSTANCE,
+    StreamPhysicalGroupTableAggregateRule.INSTANCE,
     StreamPhysicalPythonGroupAggregateRule.INSTANCE,
     StreamExecPythonGroupTableAggregateRule.INSTANCE,
     // over agg
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecGroupTableAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalGroupTableAggregateRule.scala
similarity index 84%
rename from flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecGroupTableAggregateRule.scala
rename to flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalGroupTableAggregateRule.scala
index 4022a13..ff3feac 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamExecGroupTableAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/StreamPhysicalGroupTableAggregateRule.scala
@@ -18,22 +18,26 @@
 
 package org.apache.flink.table.planner.plan.rules.physical.stream
 
-import org.apache.calcite.plan.{RelOptRule, RelOptRuleCall}
-import org.apache.calcite.rel.RelNode
-import org.apache.calcite.rel.convert.ConverterRule
 import org.apache.flink.table.planner.plan.`trait`.FlinkRelDistribution
 import org.apache.flink.table.planner.plan.nodes.FlinkConventions
 import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalTableAggregate
-import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamExecGroupTableAggregate
+import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamPhysicalGroupTableAggregate
 import org.apache.flink.table.planner.plan.utils.PythonUtil.isPythonAggregate
 
+import org.apache.calcite.plan.{RelOptRule, RelOptRuleCall}
+import org.apache.calcite.rel.RelNode
+import org.apache.calcite.rel.convert.ConverterRule
+
 import scala.collection.JavaConversions._
 
-class StreamExecGroupTableAggregateRule extends ConverterRule(
+/**
+ * Rule to convert a [[FlinkLogicalTableAggregate]] into a [[StreamPhysicalGroupTableAggregate]].
+ */
+class StreamPhysicalGroupTableAggregateRule extends ConverterRule(
     classOf[FlinkLogicalTableAggregate],
     FlinkConventions.LOGICAL,
     FlinkConventions.STREAM_PHYSICAL,
-    "StreamExecGroupTableAggregateRule") {
+    "StreamPhysicalGroupTableAggregateRule") {
 
   override def matches(call: RelOptRuleCall): Boolean = {
     val agg: FlinkLogicalTableAggregate = call.rel(0)
@@ -53,7 +57,7 @@ class StreamExecGroupTableAggregateRule extends ConverterRule(
     val providedTraitSet = rel.getTraitSet.replace(FlinkConventions.STREAM_PHYSICAL)
     val newInput: RelNode = RelOptRule.convert(agg.getInput, requiredTraitSet)
 
-    new StreamExecGroupTableAggregate(
+    new StreamPhysicalGroupTableAggregate(
       rel.getCluster,
       providedTraitSet,
       newInput,
@@ -64,7 +68,6 @@ class StreamExecGroupTableAggregateRule extends ConverterRule(
   }
 }
 
-object StreamExecGroupTableAggregateRule {
-  val INSTANCE: StreamExecGroupTableAggregateRule = new StreamExecGroupTableAggregateRule()
+object StreamPhysicalGroupTableAggregateRule {
+  val INSTANCE: StreamPhysicalGroupTableAggregateRule = new StreamPhysicalGroupTableAggregateRule()
 }
-
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
index aaa5f68..cbc71d4 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
@@ -835,7 +835,7 @@ class FlinkRelMdHandlerTestBase {
     builder.add("f1", new BasicSqlType(typeFactory.getTypeSystem, SqlTypeName.INTEGER))
     val relDataType = builder.build()
 
-    val streamExecTableAgg = new StreamExecGroupTableAggregate(
+    val streamTableAgg = new StreamPhysicalGroupTableAggregate(
       cluster,
       logicalTraits,
       studentLogicalScan,
@@ -844,7 +844,7 @@ class FlinkRelMdHandlerTestBase {
       Seq(tableAggCall)
     )
 
-    (logicalTableAgg, flinkLogicalTableAgg, streamExecTableAgg)
+    (logicalTableAgg, flinkLogicalTableAgg, streamTableAgg)
   }
 
   // equivalent Table API is

[flink] 05/08: [FLINK-20737][table-planner-blink] Introduce StreamPhysicalGlobalGroupAggregate, and make StreamExecGlobalGroupAggregate only extended from ExecNode

Posted by go...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 85e9f80b63b595e43e6926335d190a704c128ceb
Author: godfreyhe <go...@163.com>
AuthorDate: Wed Dec 23 15:56:28 2020 +0800

    [FLINK-20737][table-planner-blink] Introduce StreamPhysicalGlobalGroupAggregate, and make StreamExecGlobalGroupAggregate only extended from ExecNode
    
    This closes #14478
---
 .../stream/StreamExecGlobalGroupAggregate.java     | 226 +++++++++++++++++++++
 .../plan/metadata/FlinkRelMdColumnInterval.scala   |  10 +-
 .../plan/metadata/FlinkRelMdColumnUniqueness.scala |   2 +-
 .../FlinkRelMdFilteredColumnInterval.scala         |   4 +-
 .../metadata/FlinkRelMdModifiedMonotonicity.scala  |   2 +-
 .../plan/metadata/FlinkRelMdUniqueKeys.scala       |   2 +-
 .../stream/StreamExecGlobalGroupAggregate.scala    | 207 -------------------
 .../StreamExecIncrementalGroupAggregate.scala      |   6 +-
 .../StreamPhysicalGlobalGroupAggregate.scala       | 108 ++++++++++
 .../physical/stream/IncrementalAggregateRule.scala |  47 ++---
 .../stream/TwoStageOptimizedAggregateRule.scala    |  69 ++-----
 .../plan/metadata/FlinkRelMdHandlerTestBase.scala  |  23 +--
 12 files changed, 393 insertions(+), 313 deletions(-)

diff --git a/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGlobalGroupAggregate.java b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGlobalGroupAggregate.java
new file mode 100644
index 0000000..fe273a7
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/plan/nodes/exec/stream/StreamExecGlobalGroupAggregate.java
@@ -0,0 +1,226 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.flink.table.planner.plan.nodes.exec.stream;
+
+import org.apache.flink.api.dag.Transformation;
+import org.apache.flink.streaming.api.operators.OneInputStreamOperator;
+import org.apache.flink.streaming.api.transformations.OneInputTransformation;
+import org.apache.flink.table.api.TableConfig;
+import org.apache.flink.table.api.TableException;
+import org.apache.flink.table.api.config.ExecutionConfigOptions;
+import org.apache.flink.table.data.RowData;
+import org.apache.flink.table.planner.codegen.CodeGeneratorContext;
+import org.apache.flink.table.planner.codegen.EqualiserCodeGenerator;
+import org.apache.flink.table.planner.codegen.agg.AggsHandlerCodeGenerator;
+import org.apache.flink.table.planner.delegation.PlannerBase;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecEdge;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecNode;
+import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeBase;
+import org.apache.flink.table.planner.plan.utils.AggregateInfoList;
+import org.apache.flink.table.planner.plan.utils.AggregateUtil;
+import org.apache.flink.table.planner.plan.utils.KeySelectorUtil;
+import org.apache.flink.table.planner.utils.JavaScalaConversionUtil;
+import org.apache.flink.table.runtime.generated.GeneratedAggsHandleFunction;
+import org.apache.flink.table.runtime.generated.GeneratedRecordEqualiser;
+import org.apache.flink.table.runtime.keyselector.RowDataKeySelector;
+import org.apache.flink.table.runtime.operators.aggregate.MiniBatchGlobalGroupAggFunction;
+import org.apache.flink.table.runtime.operators.bundle.KeyedMapBundleOperator;
+import org.apache.flink.table.runtime.types.LogicalTypeDataTypeConverter;
+import org.apache.flink.table.runtime.typeutils.InternalTypeInfo;
+import org.apache.flink.table.types.DataType;
+import org.apache.flink.table.types.logical.LogicalType;
+import org.apache.flink.table.types.logical.RowType;
+
+import org.apache.calcite.rel.core.AggregateCall;
+import org.apache.calcite.tools.RelBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+/** Stream {@link ExecNode} for unbounded global group aggregate. */
+public class StreamExecGlobalGroupAggregate extends ExecNodeBase<RowData>
+        implements StreamExecNode<RowData> {
+    private static final Logger LOG = LoggerFactory.getLogger(StreamExecGlobalGroupAggregate.class);
+
+    private final int[] grouping;
+    private final AggregateCall[] aggCalls;
+    /** Each element indicates whether the corresponding agg call needs `retract` method. */
+    private final boolean[] aggCallNeedRetractions;
+    /** The input row type of this node's local agg. */
+    private final RowType localAggInputRowType;
+    /** Whether this node will generate UPDATE_BEFORE messages. */
+    private final boolean generateUpdateBefore;
+    /** Whether this node consumes retraction messages. */
+    private final boolean needRetraction;
+
+    public StreamExecGlobalGroupAggregate(
+            int[] grouping,
+            AggregateCall[] aggCalls,
+            boolean[] aggCallNeedRetractions,
+            RowType localAggInputRowType,
+            boolean generateUpdateBefore,
+            boolean needRetraction,
+            ExecEdge inputEdge,
+            RowType outputType,
+            String description) {
+        super(Collections.singletonList(inputEdge), outputType, description);
+        this.grouping = grouping;
+        this.aggCalls = aggCalls;
+        this.aggCallNeedRetractions = aggCallNeedRetractions;
+        this.localAggInputRowType = localAggInputRowType;
+        this.generateUpdateBefore = generateUpdateBefore;
+        this.needRetraction = needRetraction;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected Transformation<RowData> translateToPlanInternal(PlannerBase planner) {
+        final TableConfig tableConfig = planner.getTableConfig();
+
+        if (grouping.length > 0 && tableConfig.getMinIdleStateRetentionTime() < 0) {
+            LOG.warn(
+                    "No state retention interval configured for a query which accumulates state. "
+                            + "Please provide a query configuration with valid retention interval to prevent excessive "
+                            + "state size. You may specify a retention time of 0 to not clean up the state.");
+        }
+
+        final ExecNode<RowData> inputNode = (ExecNode<RowData>) getInputNodes().get(0);
+        final Transformation<RowData> inputTransform = inputNode.translateToPlan(planner);
+        final RowType inputRowType = (RowType) inputNode.getOutputType();
+
+        final AggregateInfoList localAggInfoList =
+                AggregateUtil.transformToStreamAggregateInfoList(
+                        localAggInputRowType,
+                        JavaScalaConversionUtil.toScala(Arrays.asList(aggCalls)),
+                        aggCallNeedRetractions,
+                        needRetraction,
+                        false,
+                        true);
+        final AggregateInfoList globalAggInfoList =
+                AggregateUtil.transformToStreamAggregateInfoList(
+                        localAggInputRowType,
+                        JavaScalaConversionUtil.toScala(Arrays.asList(aggCalls)),
+                        aggCallNeedRetractions,
+                        needRetraction,
+                        true,
+                        true);
+
+        final GeneratedAggsHandleFunction localAggsHandler =
+                generateAggsHandler(
+                        "LocalGroupAggsHandler",
+                        localAggInfoList,
+                        grouping.length,
+                        localAggInfoList.getAccTypes(),
+                        tableConfig,
+                        planner.getRelBuilder());
+
+        final GeneratedAggsHandleFunction globalAggsHandler =
+                generateAggsHandler(
+                        "GlobalGroupAggsHandler",
+                        globalAggInfoList,
+                        0,
+                        localAggInfoList.getAccTypes(),
+                        tableConfig,
+                        planner.getRelBuilder());
+
+        final int indexOfCountStar = globalAggInfoList.getIndexOfCountStar();
+        final LogicalType[] globalAccTypes =
+                Arrays.stream(globalAggInfoList.getAccTypes())
+                        .map(LogicalTypeDataTypeConverter::fromDataTypeToLogicalType)
+                        .toArray(LogicalType[]::new);
+        final LogicalType[] globalAggValueTypes =
+                Arrays.stream(globalAggInfoList.getActualValueTypes())
+                        .map(LogicalTypeDataTypeConverter::fromDataTypeToLogicalType)
+                        .toArray(LogicalType[]::new);
+        final GeneratedRecordEqualiser recordEqualiser =
+                new EqualiserCodeGenerator(globalAggValueTypes)
+                        .generateRecordEqualiser("GroupAggValueEqualiser");
+
+        final OneInputStreamOperator<RowData, RowData> operator;
+        final boolean isMiniBatchEnabled =
+                tableConfig
+                        .getConfiguration()
+                        .getBoolean(ExecutionConfigOptions.TABLE_EXEC_MINIBATCH_ENABLED);
+        if (isMiniBatchEnabled) {
+            MiniBatchGlobalGroupAggFunction aggFunction =
+                    new MiniBatchGlobalGroupAggFunction(
+                            localAggsHandler,
+                            globalAggsHandler,
+                            recordEqualiser,
+                            globalAccTypes,
+                            indexOfCountStar,
+                            generateUpdateBefore,
+                            tableConfig.getIdleStateRetention().toMillis());
+
+            operator =
+                    new KeyedMapBundleOperator<>(
+                            aggFunction, AggregateUtil.createMiniBatchTrigger(tableConfig));
+        } else {
+            throw new TableException("Local-Global optimization is only worked in miniBatch mode");
+        }
+
+        // partitioned aggregation
+        final OneInputTransformation<RowData, RowData> transform =
+                new OneInputTransformation<>(
+                        inputTransform,
+                        getDesc(),
+                        operator,
+                        InternalTypeInfo.of(getOutputType()),
+                        inputTransform.getParallelism());
+
+        if (inputsContainSingleton()) {
+            transform.setParallelism(1);
+            transform.setMaxParallelism(1);
+        }
+
+        // set KeyType and Selector for state
+        final RowDataKeySelector selector =
+                KeySelectorUtil.getRowDataSelector(grouping, InternalTypeInfo.of(inputRowType));
+        transform.setStateKeySelector(selector);
+        transform.setStateKeyType(selector.getProducedType());
+
+        return transform;
+    }
+
+    private GeneratedAggsHandleFunction generateAggsHandler(
+            String name,
+            AggregateInfoList aggInfoList,
+            int mergedAccOffset,
+            DataType[] mergedAccExternalTypes,
+            TableConfig config,
+            RelBuilder relBuilder) {
+
+        // For local aggregate, the result will be buffered, so copyInputField is true.
+        // For global aggregate, result will be put into state, then not need copy
+        // but this global aggregate result will be put into a buffered map first,
+        // then multi-put to state, so copyInputField is true.
+        AggsHandlerCodeGenerator generator =
+                new AggsHandlerCodeGenerator(
+                        new CodeGeneratorContext(config),
+                        relBuilder,
+                        JavaScalaConversionUtil.toScala(localAggInputRowType.getChildren()),
+                        true);
+
+        return generator
+                .needMerge(mergedAccOffset, true, mergedAccExternalTypes)
+                .generateAggsHandler(name, aggInfoList);
+    }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
index 9978208..5153643 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnInterval.scala
@@ -472,7 +472,7 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
     * @return interval of the given column on stream global group Aggregate
     */
   def getColumnInterval(
-      aggregate: StreamExecGlobalGroupAggregate,
+      aggregate: StreamPhysicalGlobalGroupAggregate,
       mq: RelMetadataQuery,
       index: Int): ValueInterval = estimateColumnIntervalOfAggregate(aggregate, mq, index)
 
@@ -537,7 +537,7 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
     val groupSet = aggregate match {
       case agg: StreamPhysicalGroupAggregate => agg.grouping
       case agg: StreamPhysicalLocalGroupAggregate => agg.grouping
-      case agg: StreamExecGlobalGroupAggregate => agg.grouping
+      case agg: StreamPhysicalGlobalGroupAggregate => agg.grouping
       case agg: StreamExecIncrementalGroupAggregate => agg.partialAggGrouping
       case agg: StreamExecGroupWindowAggregate => agg.getGrouping
       case agg: BatchExecGroupAggregateBase => agg.getGrouping ++ agg.getAuxGrouping
@@ -597,10 +597,10 @@ class FlinkRelMdColumnInterval private extends MetadataHandler[ColumnInterval] {
         val aggCall = aggregate match {
           case agg: StreamPhysicalGroupAggregate if agg.aggCalls.length > aggCallIndex =>
             agg.aggCalls(aggCallIndex)
-          case agg: StreamExecGlobalGroupAggregate
-            if agg.globalAggInfoList.getActualAggregateCalls.length > aggCallIndex =>
+          case agg: StreamPhysicalGlobalGroupAggregate
+            if agg.aggCalls.length > aggCallIndex =>
             val aggCallIndexInLocalAgg = getAggCallIndexInLocalAgg(
-              aggCallIndex, agg.globalAggInfoList.getActualAggregateCalls, agg.inputRowType)
+              aggCallIndex, agg.aggCalls, agg.localAggInputRowType)
             if (aggCallIndexInLocalAgg != null) {
               return fmq.getColumnInterval(agg.getInput, groupSet.length + aggCallIndexInLocalAgg)
             } else {
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala
index 13954d3..a111e79 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdColumnUniqueness.scala
@@ -349,7 +349,7 @@ class FlinkRelMdColumnUniqueness private extends MetadataHandler[BuiltInMetadata
   }
 
   def areColumnsUnique(
-      rel: StreamExecGlobalGroupAggregate,
+      rel: StreamPhysicalGlobalGroupAggregate,
       mq: RelMetadataQuery,
       columns: ImmutableBitSet,
       ignoreNulls: Boolean): JBoolean = {
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
index 5444b3b..f8c6646 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdFilteredColumnInterval.scala
@@ -20,7 +20,7 @@ package org.apache.flink.table.planner.plan.metadata
 import org.apache.flink.table.planner.plan.metadata.FlinkMetadata.FilteredColumnInterval
 import org.apache.flink.table.planner.plan.nodes.calcite.TableAggregate
 import org.apache.flink.table.planner.plan.nodes.physical.batch.BatchExecGroupAggregateBase
-import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecGlobalGroupAggregate, StreamExecGroupTableAggregate, StreamExecGroupWindowAggregate, StreamExecGroupWindowTableAggregate, StreamPhysicalGroupAggregate, StreamPhysicalLocalGroupAggregate}
+import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecGroupTableAggregate, StreamExecGroupWindowAggregate, StreamExecGroupWindowTableAggregate, StreamPhysicalGlobalGroupAggregate, StreamPhysicalGroupAggregate, StreamPhysicalLocalGroupAggregate}
 import org.apache.flink.table.planner.plan.stats.ValueInterval
 import org.apache.flink.table.planner.plan.utils.ColumnIntervalUtil
 import org.apache.flink.util.Preconditions.checkArgument
@@ -208,7 +208,7 @@ class FlinkRelMdFilteredColumnInterval private extends MetadataHandler[FilteredC
   }
 
   def getFilteredColumnInterval(
-      aggregate: StreamExecGlobalGroupAggregate,
+      aggregate: StreamPhysicalGlobalGroupAggregate,
       mq: RelMetadataQuery,
       columnIndex: Int,
       filterArg: Int): ValueInterval = {
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
index 1f2e1ee..272b557 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdModifiedMonotonicity.scala
@@ -289,7 +289,7 @@ class FlinkRelMdModifiedMonotonicity private extends MetadataHandler[ModifiedMon
   }
 
   def getRelModifiedMonotonicity(
-      rel: StreamExecGlobalGroupAggregate,
+      rel: StreamPhysicalGlobalGroupAggregate,
       mq: RelMetadataQuery): RelModifiedMonotonicity = {
     // global and local agg should have same update monotonicity
     val fmq = FlinkRelMetadataQuery.reuseOrCreate(mq)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala
index 96c5a9b..5962901 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdUniqueKeys.scala
@@ -357,7 +357,7 @@ class FlinkRelMdUniqueKeys private extends MetadataHandler[BuiltInMetadata.Uniqu
       ignoreNulls: Boolean): JSet[ImmutableBitSet] = null
 
   def getUniqueKeys(
-      rel: StreamExecGlobalGroupAggregate,
+      rel: StreamPhysicalGlobalGroupAggregate,
       mq: RelMetadataQuery,
       ignoreNulls: Boolean): JSet[ImmutableBitSet] = {
     getUniqueKeysOnAggregate(rel.grouping, mq, ignoreNulls)
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGlobalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGlobalGroupAggregate.scala
deleted file mode 100644
index 6c44b33..0000000
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecGlobalGroupAggregate.scala
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.flink.table.planner.plan.nodes.physical.stream
-
-import org.apache.flink.api.dag.Transformation
-import org.apache.flink.streaming.api.transformations.OneInputTransformation
-import org.apache.flink.table.api.config.ExecutionConfigOptions
-import org.apache.flink.table.api.{TableConfig, TableException}
-import org.apache.flink.table.data.RowData
-import org.apache.flink.table.planner.calcite.FlinkTypeFactory
-import org.apache.flink.table.planner.codegen.agg.AggsHandlerCodeGenerator
-import org.apache.flink.table.planner.codegen.{CodeGeneratorContext, EqualiserCodeGenerator}
-import org.apache.flink.table.planner.delegation.StreamPlanner
-import org.apache.flink.table.planner.plan.PartialFinalType
-import org.apache.flink.table.planner.plan.nodes.exec.LegacyStreamExecNode
-import org.apache.flink.table.planner.plan.utils.{KeySelectorUtil, _}
-import org.apache.flink.table.runtime.generated.GeneratedAggsHandleFunction
-import org.apache.flink.table.runtime.operators.aggregate.MiniBatchGlobalGroupAggFunction
-import org.apache.flink.table.runtime.operators.bundle.KeyedMapBundleOperator
-import org.apache.flink.table.runtime.types.LogicalTypeDataTypeConverter.fromDataTypeToLogicalType
-import org.apache.flink.table.runtime.typeutils.InternalTypeInfo
-import org.apache.flink.table.types.DataType
-
-import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
-import org.apache.calcite.rel.`type`.RelDataType
-import org.apache.calcite.rel.{RelNode, RelWriter}
-import org.apache.calcite.tools.RelBuilder
-
-import scala.collection.JavaConversions._
-
-/**
-  * Stream physical RelNode for unbounded global group aggregate.
-  *
-  * @see [[StreamPhysicalGroupAggregateBase]] for more info.
-  */
-class StreamExecGlobalGroupAggregate(
-    cluster: RelOptCluster,
-    traitSet: RelTraitSet,
-    inputRel: RelNode,
-    val inputRowType: RelDataType,
-    outputRowType: RelDataType,
-    val grouping: Array[Int],
-    val localAggInfoList: AggregateInfoList,
-    val globalAggInfoList: AggregateInfoList,
-    val partialFinalType: PartialFinalType)
-  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel)
-  with LegacyStreamExecNode[RowData] {
-
-  override def requireWatermark: Boolean = false
-
-  override def deriveRowType(): RelDataType = outputRowType
-
-  override def copy(traitSet: RelTraitSet, inputs: java.util.List[RelNode]): RelNode = {
-    new StreamExecGlobalGroupAggregate(
-      cluster,
-      traitSet,
-      inputs.get(0),
-      inputRowType,
-      outputRowType,
-      grouping,
-      localAggInfoList,
-      globalAggInfoList,
-      partialFinalType)
-  }
-
-  override def explainTerms(pw: RelWriter): RelWriter = {
-    super.explainTerms(pw)
-      .itemIf("groupBy",
-        RelExplainUtil.fieldToString(grouping, inputRel.getRowType), grouping.nonEmpty)
-      .itemIf("partialFinalType", partialFinalType, partialFinalType != PartialFinalType.NONE)
-      .item("select", RelExplainUtil.streamGroupAggregationToString(
-        inputRel.getRowType,
-        getRowType,
-        globalAggInfoList,
-        grouping,
-        isGlobal = true))
-  }
-
-  //~ ExecNode methods -----------------------------------------------------------
-
-  override protected def translateToPlanInternal(
-      planner: StreamPlanner): Transformation[RowData] = {
-    val tableConfig = planner.getTableConfig
-
-    if (grouping.length > 0 && tableConfig.getMinIdleStateRetentionTime < 0) {
-      LOG.warn("No state retention interval configured for a query which accumulates state. " +
-        "Please provide a query configuration with valid retention interval to prevent excessive " +
-        "state size. You may specify a retention time of 0 to not clean up the state.")
-    }
-
-    val inputTransformation = getInputNodes.get(0).translateToPlan(planner)
-      .asInstanceOf[Transformation[RowData]]
-
-    val outRowType = FlinkTypeFactory.toLogicalRowType(outputRowType)
-
-    val generateUpdateBefore = ChangelogPlanUtils.generateUpdateBefore(this)
-
-    val localAggsHandler = generateAggsHandler(
-      "LocalGroupAggsHandler",
-      localAggInfoList,
-      mergedAccOffset = grouping.length,
-      mergedAccOnHeap = true,
-      localAggInfoList.getAccTypes,
-      tableConfig,
-      planner.getRelBuilder,
-      // the local aggregate result will be buffered, so need copy
-      inputFieldCopy = true)
-
-    val globalAggsHandler = generateAggsHandler(
-      "GlobalGroupAggsHandler",
-      globalAggInfoList,
-      mergedAccOffset = 0,
-      mergedAccOnHeap = true,
-      localAggInfoList.getAccTypes,
-      tableConfig,
-      planner.getRelBuilder,
-      // if global aggregate result will be put into state, then not need copy
-      // but this global aggregate result will be put into a buffered map first,
-      // then multiput to state, so it need copy
-      inputFieldCopy = true)
-
-    val indexOfCountStar = globalAggInfoList.getIndexOfCountStar
-    val globalAccTypes = globalAggInfoList.getAccTypes.map(fromDataTypeToLogicalType)
-    val globalAggValueTypes = globalAggInfoList
-      .getActualValueTypes
-      .map(fromDataTypeToLogicalType)
-    val recordEqualiser = new EqualiserCodeGenerator(globalAggValueTypes)
-      .generateRecordEqualiser("GroupAggValueEqualiser")
-
-    val operator = if (tableConfig.getConfiguration.getBoolean(
-      ExecutionConfigOptions.TABLE_EXEC_MINIBATCH_ENABLED)) {
-      val aggFunction = new MiniBatchGlobalGroupAggFunction(
-        localAggsHandler,
-        globalAggsHandler,
-        recordEqualiser,
-        globalAccTypes,
-        indexOfCountStar,
-        generateUpdateBefore,
-        tableConfig.getIdleStateRetention.toMillis)
-
-      new KeyedMapBundleOperator(
-        aggFunction,
-        AggregateUtil.createMiniBatchTrigger(tableConfig))
-    } else {
-      throw new TableException("Local-Global optimization is only worked in miniBatch mode")
-    }
-
-    val inputTypeInfo = inputTransformation.getOutputType.asInstanceOf[InternalTypeInfo[RowData]]
-    val selector = KeySelectorUtil.getRowDataSelector(grouping, inputTypeInfo)
-
-    // partitioned aggregation
-    val ret = new OneInputTransformation(
-      inputTransformation,
-      getRelDetailedDescription,
-      operator,
-      InternalTypeInfo.of(outRowType),
-      inputTransformation.getParallelism)
-
-    if (inputsContainSingleton()) {
-      ret.setParallelism(1)
-      ret.setMaxParallelism(1)
-    }
-
-    // set KeyType and Selector for state
-    ret.setStateKeySelector(selector)
-    ret.setStateKeyType(selector.getProducedType)
-    ret
-  }
-
-  def generateAggsHandler(
-      name: String,
-      aggInfoList: AggregateInfoList,
-      mergedAccOffset: Int,
-      mergedAccOnHeap: Boolean,
-      mergedAccExternalTypes: Array[DataType],
-      config: TableConfig,
-      relBuilder: RelBuilder,
-      inputFieldCopy: Boolean): GeneratedAggsHandleFunction = {
-
-    val generator = new AggsHandlerCodeGenerator(
-      CodeGeneratorContext(config),
-      relBuilder,
-      FlinkTypeFactory.toLogicalRowType(inputRowType).getChildren,
-      inputFieldCopy)
-
-    generator
-      .needAccumulate()
-      .needMerge(mergedAccOffset, mergedAccOnHeap, mergedAccExternalTypes)
-      .generateAggsHandler(name, aggInfoList)
-  }
-
-}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
index 556c4fc..bcb6a93 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamExecIncrementalGroupAggregate.scala
@@ -48,10 +48,10 @@ import scala.collection.JavaConversions._
   *
   * <p>Considering the following sub-plan:
   * {{{
-  *   StreamExecGlobalGroupAggregate (final-global-aggregate)
+  *   StreamPhysicalGlobalGroupAggregate (final-global-aggregate)
   *   +- StreamPhysicalExchange
   *      +- StreamPhysicalLocalGroupAggregate (final-local-aggregate)
-  *         +- StreamExecGlobalGroupAggregate (partial-global-aggregate)
+  *         +- StreamPhysicalGlobalGroupAggregate (partial-global-aggregate)
   *            +- StreamPhysicalExchange
   *               +- StreamPhysicalLocalGroupAggregate (partial-local-aggregate)
   * }}}
@@ -60,7 +60,7 @@ import scala.collection.JavaConversions._
   * this node to share [[org.apache.flink.api.common.state.State]].
   * now the sub-plan is
   * {{{
-  *   StreamExecGlobalGroupAggregate (final-global-aggregate)
+  *   StreamPhysicalGlobalGroupAggregate (final-global-aggregate)
   *   +- StreamPhysicalExchange
   *      +- StreamExecIncrementalGroupAggregate
   *         +- StreamPhysicalExchange
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGlobalGroupAggregate.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGlobalGroupAggregate.scala
new file mode 100644
index 0000000..b4e0e2e
--- /dev/null
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/nodes/physical/stream/StreamPhysicalGlobalGroupAggregate.scala
@@ -0,0 +1,108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.flink.table.planner.plan.nodes.physical.stream
+
+import org.apache.flink.table.planner.calcite.FlinkTypeFactory
+import org.apache.flink.table.planner.plan.PartialFinalType
+import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecGlobalGroupAggregate
+import org.apache.flink.table.planner.plan.nodes.exec.{ExecEdge, ExecNode}
+import org.apache.flink.table.planner.plan.utils._
+
+import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
+import org.apache.calcite.rel.`type`.RelDataType
+import org.apache.calcite.rel.core.AggregateCall
+import org.apache.calcite.rel.{RelNode, RelWriter}
+
+/**
+ * Stream physical RelNode for unbounded global group aggregate.
+ *
+ * @see [[StreamPhysicalGroupAggregateBase]] for more info.
+ */
+class StreamPhysicalGlobalGroupAggregate(
+    cluster: RelOptCluster,
+    traitSet: RelTraitSet,
+    inputRel: RelNode,
+    outputRowType: RelDataType,
+    val grouping: Array[Int],
+    val aggCalls: Seq[AggregateCall],
+    aggCallNeedRetractions: Array[Boolean],
+    val localAggInputRowType: RelDataType,
+    needRetraction: Boolean,
+    val partialFinalType: PartialFinalType)
+  extends StreamPhysicalGroupAggregateBase(cluster, traitSet, inputRel) {
+
+  lazy val localAggInfoList: AggregateInfoList = AggregateUtil.transformToStreamAggregateInfoList(
+    FlinkTypeFactory.toLogicalRowType(localAggInputRowType),
+    aggCalls,
+    aggCallNeedRetractions,
+    needRetraction,
+    isStateBackendDataViews = false)
+
+  lazy val globalAggInfoList: AggregateInfoList = AggregateUtil.transformToStreamAggregateInfoList(
+    FlinkTypeFactory.toLogicalRowType(localAggInputRowType),
+    aggCalls,
+    aggCallNeedRetractions,
+    needRetraction,
+    isStateBackendDataViews = true)
+
+  override def requireWatermark: Boolean = false
+
+  override def deriveRowType(): RelDataType = outputRowType
+
+  override def copy(traitSet: RelTraitSet, inputs: java.util.List[RelNode]): RelNode = {
+    new StreamPhysicalGlobalGroupAggregate(
+      cluster,
+      traitSet,
+      inputs.get(0),
+      outputRowType,
+      grouping,
+      aggCalls,
+      aggCallNeedRetractions,
+      localAggInputRowType,
+      needRetraction,
+      partialFinalType)
+  }
+
+  override def explainTerms(pw: RelWriter): RelWriter = {
+    super.explainTerms(pw)
+      .itemIf("groupBy",
+        RelExplainUtil.fieldToString(grouping, inputRel.getRowType), grouping.nonEmpty)
+      .itemIf("partialFinalType", partialFinalType, partialFinalType != PartialFinalType.NONE)
+      .item("select", RelExplainUtil.streamGroupAggregationToString(
+        inputRel.getRowType,
+        getRowType,
+        globalAggInfoList,
+        grouping,
+        isGlobal = true))
+  }
+
+  override def translateToExecNode(): ExecNode[_] = {
+    val generateUpdateBefore = ChangelogPlanUtils.generateUpdateBefore(this)
+    new StreamExecGlobalGroupAggregate(
+      grouping,
+      aggCalls.toArray,
+      aggCallNeedRetractions,
+      FlinkTypeFactory.toLogicalRowType(localAggInputRowType),
+      generateUpdateBefore,
+      needRetraction,
+      ExecEdge.DEFAULT,
+      FlinkTypeFactory.toLogicalRowType(getRowType),
+      getRelDetailedDescription
+    )
+  }
+}
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
index ce8b563..ee8f074 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/IncrementalAggregateRule.scala
@@ -22,7 +22,7 @@ import org.apache.flink.configuration.ConfigOption
 import org.apache.flink.configuration.ConfigOptions.key
 import org.apache.flink.table.planner.calcite.{FlinkContext, FlinkTypeFactory}
 import org.apache.flink.table.planner.plan.PartialFinalType
-import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecGlobalGroupAggregate, StreamExecIncrementalGroupAggregate, StreamPhysicalLocalGroupAggregate, StreamPhysicalExchange}
+import org.apache.flink.table.planner.plan.nodes.physical.stream.{StreamExecIncrementalGroupAggregate, StreamPhysicalExchange, StreamPhysicalGlobalGroupAggregate, StreamPhysicalLocalGroupAggregate}
 import org.apache.flink.table.planner.plan.utils.{AggregateInfoList, AggregateUtil, DistinctInfo}
 import org.apache.flink.util.Preconditions
 
@@ -33,23 +33,24 @@ import java.lang.{Boolean => JBoolean}
 import java.util.Collections
 
 /**
-  * Rule that matches final [[StreamExecGlobalGroupAggregate]] on [[StreamPhysicalExchange]]
-  * on final [[StreamPhysicalLocalGroupAggregate]] on partial [[StreamExecGlobalGroupAggregate]],
-  * and combines the final [[StreamPhysicalLocalGroupAggregate]] and
-  * the partial [[StreamExecGlobalGroupAggregate]] into a [[StreamExecIncrementalGroupAggregate]].
-  */
+ * Rule that matches final [[StreamPhysicalGlobalGroupAggregate]] on [[StreamPhysicalExchange]]
+ * on final [[StreamPhysicalLocalGroupAggregate]] on partial [[StreamPhysicalGlobalGroupAggregate]],
+ * and combines the final [[StreamPhysicalLocalGroupAggregate]] and
+ * the partial [[StreamPhysicalGlobalGroupAggregate]] into a
+ * [[StreamExecIncrementalGroupAggregate]].
+ */
 class IncrementalAggregateRule
   extends RelOptRule(
-    operand(classOf[StreamExecGlobalGroupAggregate], // final global agg
+    operand(classOf[StreamPhysicalGlobalGroupAggregate], // final global agg
       operand(classOf[StreamPhysicalExchange], // key by
         operand(classOf[StreamPhysicalLocalGroupAggregate], // final local agg
-          operand(classOf[StreamExecGlobalGroupAggregate], any())))), // partial global agg
+          operand(classOf[StreamPhysicalGlobalGroupAggregate], any())))), // partial global agg
     "IncrementalAggregateRule") {
 
   override def matches(call: RelOptRuleCall): Boolean = {
-    val finalGlobalAgg: StreamExecGlobalGroupAggregate = call.rel(0)
+    val finalGlobalAgg: StreamPhysicalGlobalGroupAggregate = call.rel(0)
     val finalLocalAgg: StreamPhysicalLocalGroupAggregate = call.rel(2)
-    val partialGlobalAgg: StreamExecGlobalGroupAggregate = call.rel(3)
+    val partialGlobalAgg: StreamPhysicalGlobalGroupAggregate = call.rel(3)
 
     val tableConfig = call.getPlanner.getContext.unwrap(classOf[FlinkContext]).getTableConfig
 
@@ -64,11 +65,11 @@ class IncrementalAggregateRule
   }
 
   override def onMatch(call: RelOptRuleCall): Unit = {
-    val finalGlobalAgg: StreamExecGlobalGroupAggregate = call.rel(0)
+    val finalGlobalAgg: StreamPhysicalGlobalGroupAggregate = call.rel(0)
     val exchange: StreamPhysicalExchange = call.rel(1)
     val finalLocalAgg: StreamPhysicalLocalGroupAggregate = call.rel(2)
-    val partialGlobalAgg: StreamExecGlobalGroupAggregate = call.rel(3)
-    val aggInputRowType = partialGlobalAgg.inputRowType
+    val partialGlobalAgg: StreamPhysicalGlobalGroupAggregate = call.rel(3)
+    val aggInputRowType = partialGlobalAgg.localAggInputRowType
 
     val partialLocalAggInfoList = partialGlobalAgg.localAggInfoList
     val partialGlobalAggInfoList = partialGlobalAgg.globalAggInfoList
@@ -141,16 +142,6 @@ class IncrementalAggregateRule
         needInputCount = false,
         // the local agg is not works on state
         isStateBackendDataViews = false)
-      val globalAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
-        // the final agg input is partial agg
-        FlinkTypeFactory.toLogicalRowType(partialGlobalAgg.getRowType),
-        aggCalls,
-        // all the aggs do not need retraction
-        Array.fill(aggCalls.length)(false),
-        // also do not need count*
-        needInputCount = false,
-        // the global agg is works on state
-        isStateBackendDataViews = true)
 
       // check whether the global agg required input row type equals the incr agg output row type
       val globalAggInputAccType = AggregateUtil.inferLocalAggRowType(
@@ -164,15 +155,17 @@ class IncrementalAggregateRule
         globalAggInputAccType,
         false))
 
-      new StreamExecGlobalGroupAggregate(
+      new StreamPhysicalGlobalGroupAggregate(
         finalGlobalAgg.getCluster,
         finalGlobalAgg.getTraitSet,
         newExchange,
-        finalGlobalAgg.inputRowType,
         finalGlobalAgg.getRowType,
         finalGlobalAgg.grouping,
-        localAggInfoList, // the agg info list is changed
-        globalAggInfoList, // the agg info list is changed
+        aggCalls,
+        // all the aggs do not need retraction
+        Array.fill(aggCalls.length)(false),
+        finalGlobalAgg.localAggInputRowType,
+        needRetraction = false,
         finalGlobalAgg.partialFinalType)
     }
 
diff --git a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
index 2f804cc..1399bcf 100644
--- a/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
+++ b/flink-table/flink-table-planner-blink/src/main/scala/org/apache/flink/table/planner/plan/rules/physical/stream/TwoStageOptimizedAggregateRule.scala
@@ -25,14 +25,13 @@ import org.apache.flink.table.planner.plan.metadata.FlinkRelMetadataQuery
 import org.apache.flink.table.planner.plan.nodes.FlinkConventions
 import org.apache.flink.table.planner.plan.nodes.physical.stream._
 import org.apache.flink.table.planner.plan.rules.physical.FlinkExpandConversionRule._
-import org.apache.flink.table.planner.plan.utils.{AggregateInfoList, AggregateUtil, ChangelogPlanUtils}
+import org.apache.flink.table.planner.plan.utils.{AggregateUtil, ChangelogPlanUtils}
 import org.apache.flink.table.planner.utils.AggregatePhaseStrategy
 import org.apache.flink.table.planner.utils.TableConfigUtils.getAggPhaseStrategy
 
 import org.apache.calcite.plan.RelOptRule.{any, operand}
 import org.apache.calcite.plan.{RelOptRule, RelOptRuleCall}
 import org.apache.calcite.rel.RelNode
-import org.apache.calcite.rel.core.AggregateCall
 
 import java.util
 
@@ -46,7 +45,7 @@ import java.util
   *
   * and converts them to
   * {{{
-  *   StreamExecGlobalGroupAggregate
+  *   StreamPhysicalGlobalGroupAggregate
   *   +- StreamPhysicalExchange
   *      +- StreamPhysicalLocalGroupAggregate
   *         +- input of exchange
@@ -93,76 +92,50 @@ class TwoStageOptimizedAggregateRule extends RelOptRule(
   }
 
   override def onMatch(call: RelOptRuleCall): Unit = {
-    val agg: StreamPhysicalGroupAggregate = call.rel(0)
+    val originalAgg: StreamPhysicalGroupAggregate = call.rel(0)
     val realInput: RelNode = call.rel(2)
     val needRetraction = !ChangelogPlanUtils.isInsertOnly(
       realInput.asInstanceOf[StreamPhysicalRel])
     val fmq = FlinkRelMetadataQuery.reuseOrCreate(call.getMetadataQuery)
-    val monotonicity = fmq.getRelModifiedMonotonicity(agg)
+    val monotonicity = fmq.getRelModifiedMonotonicity(originalAgg)
     val aggCallNeedRetractions = AggregateUtil.deriveAggCallNeedRetractions(
-      agg.grouping.length, agg.aggCalls, needRetraction, monotonicity)
-
-    val globalAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
-      FlinkTypeFactory.toLogicalRowType(realInput.getRowType),
-      agg.aggCalls,
-      aggCallNeedRetractions,
-      needRetraction,
-      isStateBackendDataViews = true)
-
-    val globalHashAgg = createTwoStageAgg(
-      realInput, agg.aggCalls, aggCallNeedRetractions, needRetraction, globalAggInfoList, agg)
-    call.transformTo(globalHashAgg)
-  }
-
-  // the difference between localAggInfos and aggInfos is local agg use heap dataview,
-  // but global agg use state dataview
-  private def createTwoStageAgg(
-      realInput: RelNode,
-      aggCalls: Seq[AggregateCall],
-      aggCallNeedRetractions: Array[Boolean],
-      needRetraction: Boolean,
-      globalAggInfoList: AggregateInfoList,
-      agg: StreamPhysicalGroupAggregate): StreamExecGlobalGroupAggregate = {
+      originalAgg.grouping.length, originalAgg.aggCalls, needRetraction, monotonicity)
 
     // local agg shouldn't produce insert only messages
     val localAggTraitSet = realInput.getTraitSet
       .plus(ModifyKindSetTrait.INSERT_ONLY)
       .plus(UpdateKindTrait.NONE)
     val localHashAgg = new StreamPhysicalLocalGroupAggregate(
-      agg.getCluster,
+      originalAgg.getCluster,
       localAggTraitSet,
       realInput,
-      agg.grouping,
-      agg.aggCalls,
+      originalAgg.grouping,
+      originalAgg.aggCalls,
       aggCallNeedRetractions,
       needRetraction,
-      agg.partialFinalType)
+      originalAgg.partialFinalType)
 
     // grouping keys is forwarded by local agg, use indices instead of groupings
-    val globalGrouping = agg.grouping.indices.toArray
+    val globalGrouping = originalAgg.grouping.indices.toArray
     val globalDistribution = createDistribution(globalGrouping)
     // create exchange if needed
     val newInput = satisfyDistribution(
       FlinkConventions.STREAM_PHYSICAL, localHashAgg, globalDistribution)
-    val globalAggProvidedTraitSet = agg.getTraitSet
+    val globalAggProvidedTraitSet = originalAgg.getTraitSet
 
-    // TODO Temporary solution, remove it later
-    val localAggInfoList = AggregateUtil.transformToStreamAggregateInfoList(
-      FlinkTypeFactory.toLogicalRowType(realInput.getRowType),
-      aggCalls,
-      aggCallNeedRetractions,
-      needRetraction,
-      isStateBackendDataViews = false)
-    new StreamExecGlobalGroupAggregate(
-      agg.getCluster,
+   val globalAgg = new StreamPhysicalGlobalGroupAggregate(
+      originalAgg.getCluster,
       globalAggProvidedTraitSet,
       newInput,
-      realInput.getRowType,
-      agg.getRowType,
+      originalAgg.getRowType,
       globalGrouping,
-      localAggInfoList,
-      globalAggInfoList,
-      agg.partialFinalType)
+      originalAgg.aggCalls,
+      aggCallNeedRetractions,
+      realInput.getRowType,
+      needRetraction,
+      originalAgg.partialFinalType)
+
+    call.transformTo(globalAgg)
   }
 
   private def createDistribution(keys: Array[Int]): FlinkRelDistribution = {
diff --git a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
index ec2d55c..aaa5f68 100644
--- a/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
+++ b/flink-table/flink-table-planner-blink/src/test/scala/org/apache/flink/table/planner/plan/metadata/FlinkRelMdHandlerTestBase.scala
@@ -44,7 +44,6 @@ import org.apache.flink.table.planner.plan.nodes.physical.batch._
 import org.apache.flink.table.planner.plan.nodes.physical.stream._
 import org.apache.flink.table.planner.plan.schema.FlinkPreparingTableBase
 import org.apache.flink.table.planner.plan.stream.sql.join.TestTemporalTable
-import org.apache.flink.table.planner.plan.utils.AggregateUtil.transformToStreamAggregateInfoList
 import org.apache.flink.table.planner.plan.utils._
 import org.apache.flink.table.planner.utils.{CountAggFunction, Top3}
 import org.apache.flink.table.runtime.operators.rank.{ConstantRankRange, RankType, VariableRankRange}
@@ -1033,28 +1032,16 @@ class FlinkRelMdHandlerTestBase {
 
     val streamExchange1 = new StreamPhysicalExchange(
       cluster, streamLocalAgg.getTraitSet.replace(hash0), streamLocalAgg, hash0)
-    val globalAggInfoList = transformToStreamAggregateInfoList(
-      FlinkTypeFactory.toLogicalRowType(streamExchange1.getRowType),
-      aggCalls,
-      aggCallNeedRetractions,
-      needInputCount = false,
-      isStateBackendDataViews = true)
-    // TODO Temporary solution, remove it later
-    val localAggInfoList = transformToStreamAggregateInfoList(
-      FlinkTypeFactory.toLogicalRowType(studentStreamScan.getRowType),
-      aggCalls,
-      aggCallNeedRetractions,
-      needInputCount = false,
-      isStateBackendDataViews = false)
-    val streamGlobalAgg = new StreamExecGlobalGroupAggregate(
+    val streamGlobalAgg = new StreamPhysicalGlobalGroupAggregate(
       cluster,
       streamPhysicalTraits,
       streamExchange1,
-      streamExchange1.getRowType,
       rowTypeOfGlobalAgg,
       Array(0),
-      localAggInfoList,
-      globalAggInfoList,
+      aggCalls,
+      aggCallNeedRetractions,
+      streamLocalAgg.getInput.getRowType,
+      AggregateUtil.needRetraction(streamLocalAgg),
       PartialFinalType.NONE)
 
     val streamExchange2 = new StreamPhysicalExchange(cluster,