From 2b799e7d3c9af45694b20bd534a5f10dc9402e63 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Thu, 9 May 2024 22:23:23 +0800
Subject: [PATCH 01/28] add temp impl

---
 .../java/org/apache/iotdb/SessionExample.java |  29 ++-
 .../plan/analyze/AnalyzeVisitor.java          |   6 +-
 .../analyze/TemplatedAggregationAnalyze.java  | 122 +++++++++++++
 .../plan/analyze/TemplatedAnalyze.java        | 100 +++++------
 .../plan/analyze/TemplatedInfo.java           |   5 +
 .../plan/planner/LogicalPlanBuilder.java      |   4 +-
 .../plan/planner/TemplatedLogicalPlan.java    | 165 +++++++++++++++++-
 .../planner/TemplatedLogicalPlanBuilder.java  |  55 ++++++
 8 files changed, 430 insertions(+), 56 deletions(-)
 create mode 100644 iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java

diff --git a/example/session/src/main/java/org/apache/iotdb/SessionExample.java b/example/session/src/main/java/org/apache/iotdb/SessionExample.java
index 0daec0885bf7..e65127fd3883 100644
--- a/example/session/src/main/java/org/apache/iotdb/SessionExample.java
+++ b/example/session/src/main/java/org/apache/iotdb/SessionExample.java
@@ -61,12 +61,39 @@ public class SessionExample {
   private static final String ROOT_SG1_D1 = "root.sg1.d1";
   private static final String ROOT_SG1 = "root.sg1";
   private static final String LOCAL_HOST = "127.0.0.1";
-  public static final String SELECT_D1 = "select * from root.sg1.d1";
+  public static final String SELECT_D1 =
+      "select value from root.cmadaas_nafp_surf.nafp.NAFP_GRAPES_MESO_FOR_3KM.data.RHU.`100`.`100000`.tile limit 10";
 
   private static Random random = new Random();
 
   public static void main(String[] args)
       throws IoTDBConnectionException, StatementExecutionException {
+    session =
+        new Session.Builder()
+            .host("172.20.31.60")
+            .port(6667)
+            .username("root")
+            .password("root")
+            .version(Version.V_1_0)
+            .build();
+    session.open(false);
+
+    // set session fetchSize
+    session.setFetchSize(10000);
+
+    long time1 = System.currentTimeMillis();
+    try (SessionDataSet dataSet = session.executeQueryStatement(SELECT_D1)) {
+      // System.out.println(dataSet.getColumnNames());
+      //      dataSet.setFetchSize(1024); // default is 10000
+      //      while (dataSet.hasNext()) {
+      //        System.out.println(dataSet.next());
+      //      }
+    }
+    System.out.println("Time: " + (System.currentTimeMillis() - time1));
+  }
+
+  public static void main1(String[] args)
+      throws IoTDBConnectionException, StatementExecutionException {
     session =
         new Session.Builder()
             .host(LOCAL_HOST)
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
index b23a5d44f9cf..f0086b5e79a9 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
@@ -1848,7 +1848,8 @@ private void checkGroupByConditionExpressionType(
           && rightExpression instanceof ConstantOperand)) {
         throw new SemanticException(
             String.format(
-                "Please check the keep condition ([%s]),it need to be a constant or a compare expression constructed by 'keep' and a long number.",
+                "Please check the keep condition ([%s]), "
+                    + "it need to be a constant or a compare expression constructed by 'keep' and a long number.",
                 keepExpression.getExpressionString()));
       }
       return;
@@ -1856,7 +1857,8 @@ private void checkGroupByConditionExpressionType(
     if (!(keepExpression instanceof ConstantOperand)) {
       throw new SemanticException(
           String.format(
-              "Please check the keep condition ([%s]),it need to be a constant or a compare expression constructed by 'keep' and a long number.",
+              "Please check the keep condition ([%s]), "
+                  + "it need to be a constant or a compare expression constructed by 'keep' and a long number.",
               keepExpression.getExpressionString()));
     }
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
new file mode 100644
index 000000000000..ae2afa9c8f56
--- /dev/null
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -0,0 +1,122 @@
+package org.apache.iotdb.db.queryengine.plan.analyze;
+
+import org.apache.iotdb.commons.path.PartialPath;
+import org.apache.iotdb.db.queryengine.common.MPPQueryContext;
+import org.apache.iotdb.db.queryengine.common.schematree.ISchemaTree;
+import org.apache.iotdb.db.queryengine.plan.expression.Expression;
+import org.apache.iotdb.db.queryengine.plan.expression.leaf.ConstantOperand;
+import org.apache.iotdb.db.queryengine.plan.statement.component.ResultColumn;
+import org.apache.iotdb.db.queryengine.plan.statement.crud.QueryStatement;
+import org.apache.iotdb.db.schemaengine.template.Template;
+
+import org.apache.tsfile.utils.Pair;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+
+import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.DEVICE_EXPRESSION;
+import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.END_TIME_EXPRESSION;
+import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeOutput;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDataPartition;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDeviceToWhere;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDeviceViewInput;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDeviceViewOutput;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeFrom;
+import static org.apache.iotdb.db.queryengine.plan.optimization.LimitOffsetPushDown.canPushDownLimitOffsetInGroupByTimeForDevice;
+import static org.apache.iotdb.db.queryengine.plan.optimization.LimitOffsetPushDown.pushDownLimitOffsetInGroupByTimeForDevice;
+
+public class TemplatedAggregationAnalyze {
+
+  // ----------- Methods below are used for aggregation, templated with align by device --------
+
+  static boolean analyzeAggregation(
+      Analysis analysis,
+      QueryStatement queryStatement,
+      IPartitionFetcher partitionFetcher,
+      ISchemaTree schemaTree,
+      MPPQueryContext context,
+      Template template) {
+
+    List<PartialPath> deviceList = analyzeFrom(queryStatement, schemaTree);
+
+    if (canPushDownLimitOffsetInGroupByTimeForDevice(queryStatement)) {
+      // remove the device which won't appear in resultSet after limit/offset
+      deviceList = pushDownLimitOffsetInGroupByTimeForDevice(deviceList, queryStatement);
+    }
+
+    analyzeDeviceToWhere(analysis, queryStatement);
+    if (deviceList.isEmpty()) {
+      analysis.setFinishQueryAfterAnalyze(true);
+      return true;
+    }
+    analysis.setDeviceList(deviceList);
+
+    List<Pair<Expression, String>> outputExpressions = new ArrayList<>();
+    ColumnPaginationController paginationController =
+        new ColumnPaginationController(
+            queryStatement.getSeriesLimit(), queryStatement.getSeriesOffset());
+    for (ResultColumn resultColumn : queryStatement.getSelectComponent().getResultColumns()) {}
+
+    analyzeSelect(queryStatement, analysis, outputExpressions, template);
+    if (analysis.getWhereExpression() != null
+        && analysis.getWhereExpression().equals(ConstantOperand.FALSE)) {
+      analyzeOutput(analysis, queryStatement, outputExpressions);
+      analysis.setFinishQueryAfterAnalyze(true);
+      return true;
+    }
+
+    analyzeDeviceToAggregation(analysis);
+    analyzeDeviceToSourceTransform(analysis);
+    analyzeDeviceToSource(analysis);
+
+    analyzeDeviceViewOutput(analysis, queryStatement);
+    analyzeDeviceViewInput(analysis);
+
+    // generate result set header according to output expressions
+    analyzeOutput(analysis, queryStatement, outputExpressions);
+
+    context.generateGlobalTimeFilter(analysis);
+    // fetch partition information
+    analyzeDataPartition(analysis, schemaTree, partitionFetcher, context.getGlobalTimeFilter());
+    return true;
+  }
+
+  private static void analyzeSelect(
+      QueryStatement queryStatement,
+      Analysis analysis,
+      List<Pair<Expression, String>> outputExpressions,
+      Template template) {
+    LinkedHashSet<Expression> selectExpressions = new LinkedHashSet<>();
+    selectExpressions.add(DEVICE_EXPRESSION);
+    if (queryStatement.isOutputEndTime()) {
+      selectExpressions.add(END_TIME_EXPRESSION);
+    }
+    for (Pair<Expression, String> pair : outputExpressions) {
+      Expression selectExpression = pair.left;
+      selectExpressions.add(selectExpression);
+    }
+    analysis.setOutputExpressions(outputExpressions);
+    analysis.setSelectExpressions(selectExpressions);
+    analysis.setDeviceTemplate(template);
+    // TODO only add measurement and schema occured in selectExpressions
+    analysis.setMeasurementList(new ArrayList<>(template.getSchemaMap().keySet()));
+    analysis.setMeasurementSchemaList(new ArrayList<>(template.getSchemaMap().values()));
+  }
+
+  private static void analyzeDeviceToSourceTransform(Analysis analysis) {
+    // TODO add having into SourceTransform
+    analysis.setDeviceToSourceTransformExpressions(analysis.getDeviceToSelectExpressions());
+  }
+
+  private static void analyzeDeviceToSource(Analysis analysis) {
+    // TODO add having into Source
+    analysis.setDeviceToSourceExpressions(analysis.getDeviceToSelectExpressions());
+    analysis.setDeviceToOutputExpressions(analysis.getDeviceToSelectExpressions());
+  }
+
+  private static void analyzeDeviceToAggregation(Analysis analysis) {
+    // TODO need add having clause?
+    analysis.setDeviceToAggregationExpressions(analysis.getDeviceToSelectExpressions());
+  }
+}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
index 856476eae241..1814a923d241 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
@@ -71,6 +71,7 @@
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.concatDeviceAndBindSchemaForExpression;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.getMeasurementExpression;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionTypeAnalyzer.analyzeExpressionForTemplatedQuery;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAggregationAnalyze.analyzeAggregation;
 
 /**
  * This class provides accelerated implementation for multiple devices align by device query. This
@@ -96,9 +97,8 @@ public static boolean canBuildPlanUseTemplate(
       IPartitionFetcher partitionFetcher,
       ISchemaTree schemaTree,
       MPPQueryContext context) {
-    if (queryStatement.isAggregationQuery()
-        || queryStatement.isGroupBy()
-        || queryStatement.isGroupByTime()
+    if (queryStatement.isGroupBy()
+        || (queryStatement.isGroupByTime() && !queryStatement.isAggregationQuery())
         || queryStatement.isSelectInto()
         || queryStatement.hasFill()
         || schemaTree.hasNormalTimeSeries()) {
@@ -106,58 +106,61 @@ public static boolean canBuildPlanUseTemplate(
     }
 
     List<Template> templates = schemaTree.getUsingTemplates();
-    if (templates.size() != 1) {
+    if (templates.size() != 1 || templates.get(0) == null) {
       return false;
     }
 
     Template template = templates.get(0);
 
+    if (queryStatement.isAggregationQuery()) {
+      return analyzeAggregation(
+          analysis, queryStatement, partitionFetcher, schemaTree, context, template);
+    }
+
     List<Pair<Expression, String>> outputExpressions = new ArrayList<>();
     ColumnPaginationController paginationController =
         new ColumnPaginationController(
             queryStatement.getSeriesLimit(), queryStatement.getSeriesOffset());
-    if (template != null) {
-      for (ResultColumn resultColumn : queryStatement.getSelectComponent().getResultColumns()) {
-        Expression expression = resultColumn.getExpression();
-        if ("*".equals(expression.getOutputSymbol())) {
-          for (Map.Entry<String, IMeasurementSchema> entry : template.getSchemaMap().entrySet()) {
-            if (paginationController.hasCurOffset()) {
-              paginationController.consumeOffset();
-            } else if (paginationController.hasCurLimit()) {
-              String measurementName = entry.getKey();
-              IMeasurementSchema measurementSchema = entry.getValue();
-              TimeSeriesOperand measurementPath =
-                  new TimeSeriesOperand(
-                      new MeasurementPath(new String[] {measurementName}, measurementSchema));
-              outputExpressions.add(new Pair<>(measurementPath, null));
-              paginationController.consumeLimit();
-            } else {
-              break;
-            }
-          }
-          if (queryStatement.getSelectComponent().getResultColumns().size() == 1
-              && queryStatement.getSeriesOffset() == 0
-              && queryStatement.getSeriesLimit() == 0) {
-            analysis.setTemplateWildCardQuery();
+    for (ResultColumn resultColumn : queryStatement.getSelectComponent().getResultColumns()) {
+      Expression expression = resultColumn.getExpression();
+      if ("*".equals(expression.getOutputSymbol())) {
+        for (Map.Entry<String, IMeasurementSchema> entry : template.getSchemaMap().entrySet()) {
+          if (paginationController.hasCurOffset()) {
+            paginationController.consumeOffset();
+          } else if (paginationController.hasCurLimit()) {
+            String measurementName = entry.getKey();
+            IMeasurementSchema measurementSchema = entry.getValue();
+            TimeSeriesOperand measurementPath =
+                new TimeSeriesOperand(
+                    new MeasurementPath(new String[] {measurementName}, measurementSchema));
+            outputExpressions.add(new Pair<>(measurementPath, null));
+            paginationController.consumeLimit();
+          } else {
+            break;
           }
-        } else if (expression instanceof TimeSeriesOperand) {
-          String measurementName = ((TimeSeriesOperand) expression).getPath().getMeasurement();
-          if (template.getSchemaMap().containsKey(measurementName)) {
-            if (paginationController.hasCurOffset()) {
-              paginationController.consumeOffset();
-            } else if (paginationController.hasCurLimit()) {
-              IMeasurementSchema measurementSchema = template.getSchemaMap().get(measurementName);
-              TimeSeriesOperand measurementPath =
-                  new TimeSeriesOperand(
-                      new MeasurementPath(new String[] {measurementName}, measurementSchema));
-              outputExpressions.add(new Pair<>(measurementPath, resultColumn.getAlias()));
-            } else {
-              break;
-            }
+        }
+        if (queryStatement.getSelectComponent().getResultColumns().size() == 1
+            && queryStatement.getSeriesOffset() == 0
+            && queryStatement.getSeriesLimit() == 0) {
+          analysis.setTemplateWildCardQuery();
+        }
+      } else if (expression instanceof TimeSeriesOperand) {
+        String measurementName = ((TimeSeriesOperand) expression).getPath().getMeasurement();
+        if (template.getSchemaMap().containsKey(measurementName)) {
+          if (paginationController.hasCurOffset()) {
+            paginationController.consumeOffset();
+          } else if (paginationController.hasCurLimit()) {
+            IMeasurementSchema measurementSchema = template.getSchemaMap().get(measurementName);
+            TimeSeriesOperand measurementPath =
+                new TimeSeriesOperand(
+                    new MeasurementPath(new String[] {measurementName}, measurementSchema));
+            outputExpressions.add(new Pair<>(measurementPath, resultColumn.getAlias()));
+          } else {
+            break;
           }
-        } else {
-          return false;
         }
+      } else {
+        return false;
       }
     }
 
@@ -228,8 +231,7 @@ private static void analyzeSelect(
     analysis.setMeasurementSchemaList(measurementSchemaList);
   }
 
-  private static List<PartialPath> analyzeFrom(
-      QueryStatement queryStatement, ISchemaTree schemaTree) {
+  static List<PartialPath> analyzeFrom(QueryStatement queryStatement, ISchemaTree schemaTree) {
     // device path patterns in FROM clause
     List<PartialPath> devicePatternList = queryStatement.getFromComponent().getPrefixPaths();
 
@@ -246,7 +248,7 @@ private static List<PartialPath> analyzeFrom(
         : deviceSet.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
   }
 
-  private static void analyzeDeviceToWhere(Analysis analysis, QueryStatement queryStatement) {
+  static void analyzeDeviceToWhere(Analysis analysis, QueryStatement queryStatement) {
     if (!queryStatement.hasWhere()) {
       return;
     }
@@ -325,7 +327,7 @@ private static void analyzeDeviceToSourceTransform(Analysis analysis) {
     analysis.setDeviceToSourceTransformExpressions(analysis.getDeviceToSelectExpressions());
   }
 
-  private static void analyzeDeviceViewOutput(Analysis analysis, QueryStatement queryStatement) {
+  static void analyzeDeviceViewOutput(Analysis analysis, QueryStatement queryStatement) {
     Set<Expression> selectExpressions = analysis.getSelectExpressions();
     // TODO if no order by, just set deviceViewOutputExpressions as selectExpressions
     Set<Expression> deviceViewOutputExpressions = new LinkedHashSet<>(selectExpressions);
@@ -337,7 +339,7 @@ private static void analyzeDeviceViewOutput(Analysis analysis, QueryStatement qu
         analyzeDeviceViewSpecialProcess(deviceViewOutputExpressions, queryStatement, analysis));
   }
 
-  private static void analyzeDeviceViewInput(Analysis analysis) {
+  static void analyzeDeviceViewInput(Analysis analysis) {
     List<Integer> indexes = new ArrayList<>();
 
     // index-0 is `Device`
@@ -356,7 +358,7 @@ private static void analyzeDeviceToSource(Analysis analysis) {
     analysis.setDeviceToOutputExpressions(analysis.getDeviceToSelectExpressions());
   }
 
-  private static void analyzeDataPartition(
+  static void analyzeDataPartition(
       Analysis analysis,
       ISchemaTree schemaTree,
       IPartitionFetcher partitionFetcher,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
index bd624f25634c..bf5d54e5cd62 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
@@ -39,6 +39,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import static org.apache.iotdb.db.queryengine.plan.expression.leaf.TimestampOperand.TIMESTAMP_EXPRESSION_STRING;
 
@@ -77,6 +78,10 @@ public class TemplatedInfo {
   // variables related to predicate push down
   private Expression pushDownPredicate;
 
+  private Set<Expression> aggSelectExpressions;
+
+  private Expression havingExpression;
+
   public TemplatedInfo(
       List<String> measurementList,
       List<IMeasurementSchema> schemaList,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
index d457c432cf08..7ce23590e23b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
@@ -743,7 +743,7 @@ public LogicalPlanBuilder planSlidingWindowAggregation(
     return this;
   }
 
-  private PlanNode createSlidingWindowAggregationNode(
+  protected PlanNode createSlidingWindowAggregationNode(
       PlanNode child,
       Set<Expression> aggregationExpressions,
       GroupByTimeParameter groupByTimeParameter,
@@ -848,7 +848,7 @@ private PlanNode createGroupByTagNode(
             .collect(Collectors.toList()));
   }
 
-  private List<AggregationDescriptor> constructAggregationDescriptorList(
+  protected List<AggregationDescriptor> constructAggregationDescriptorList(
       Set<Expression> aggregationExpressions, AggregationStep curStep) {
     return aggregationExpressions.stream()
         .map(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
index 75222efb6fc9..7bb9ebd579ca 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
@@ -26,6 +26,7 @@
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimeSeriesOperand;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationStep;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.InputLocation;
 import org.apache.iotdb.db.queryengine.plan.statement.crud.QueryStatement;
 
@@ -86,10 +87,67 @@ public TemplatedLogicalPlan(
     this.whereExpression = analysis.getWhereExpression();
 
     // for align by device query with template, most used variables are same
-    initCommonVariables();
+    if (queryStatement.isAggregationQuery()) {
+      initAggQueryCommonVariables();
+    } else {
+      initNonAggQueryCommonVariables();
+    }
+  }
+
+  private void initAggQueryCommonVariables() {
+    if (whereExpression != null) {
+      newMeasurementList = new ArrayList<>(measurementList);
+      newSchemaList = new ArrayList<>(schemaList);
+      Set<String> selectMeasurements = new HashSet<>(measurementList);
+      List<Expression> whereSourceExpressions = searchSourceExpressions(whereExpression);
+      for (Expression expression : whereSourceExpressions) {
+        if (expression instanceof TimeSeriesOperand) {
+          String measurement = ((TimeSeriesOperand) expression).getPath().getMeasurement();
+          if (!analysis.getDeviceTemplate().getSchemaMap().containsKey(measurement)) {
+            continue;
+          }
+          if (!selectMeasurements.contains(measurement)) {
+            newMeasurementList.add(measurement);
+            newSchemaList.add(analysis.getDeviceTemplate().getSchema(measurement));
+          }
+        }
+      }
+
+      // TODO fix aggregation filterLayoutMap
+      filterLayoutMap = makeLayout(newMeasurementList);
+
+      analysis
+          .getExpressionTypes()
+          .forEach(
+              (key, value) ->
+                  context.getTypeProvider().setType(key.getNode().getOutputSymbol(), value));
+    }
+
+    context
+        .getTypeProvider()
+        .setTemplatedInfo(
+            new TemplatedInfo(
+                newMeasurementList,
+                newSchemaList,
+                newSchemaList.stream()
+                    .map(IMeasurementSchema::getType)
+                    .collect(Collectors.toList()),
+                queryStatement.getResultTimeOrder(),
+                analysis.isLastLevelUseWildcard(),
+                analysis.getDeviceViewOutputExpressions().stream()
+                    .map(Expression::getExpressionString)
+                    .collect(Collectors.toList()),
+                analysis.getDeviceViewInputIndexesMap().values().iterator().next(),
+                OFFSET_VALUE,
+                limitValue,
+                whereExpression,
+                queryStatement.isGroupByTime(),
+                analysis.getDeviceTemplate().getSchemaMap(),
+                filterLayoutMap,
+                null));
   }
 
-  private void initCommonVariables() {
+  private void initNonAggQueryCommonVariables() {
     if (whereExpression != null) {
       if (!analysis.isTemplateWildCardQuery()) {
         newMeasurementList = new ArrayList<>(measurementList);
@@ -145,6 +203,10 @@ private void initCommonVariables() {
   }
 
   public PlanNode visitQuery() {
+    if (queryStatement.isAggregationQuery()) {
+      return visitAggregation();
+    }
+
     LogicalPlanBuilder planBuilder =
         new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList);
 
@@ -193,6 +255,56 @@ public PlanNode visitQuery() {
     return planBuilder.getRoot();
   }
 
+  private PlanNode visitAggregation() {
+    LogicalPlanBuilder planBuilder =
+        new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList);
+
+    Map<String, PlanNode> deviceToSubPlanMap = new LinkedHashMap<>();
+    for (PartialPath devicePath : analysis.getDeviceList()) {
+      String deviceName = devicePath.getFullPath();
+      PlanNode rootNode = visitDeviceAggregationBody(devicePath);
+
+      LogicalPlanBuilder subPlanBuilder =
+          new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList)
+              .withNewRoot(rootNode);
+
+      deviceToSubPlanMap.put(deviceName, subPlanBuilder.getRoot());
+    }
+
+    // convert to ALIGN BY DEVICE view
+    planBuilder =
+        planBuilder.planDeviceView(
+            deviceToSubPlanMap,
+            analysis.getDeviceViewOutputExpressions(),
+            analysis.getDeviceViewInputIndexesMap(),
+            analysis.getSelectExpressions(),
+            queryStatement,
+            analysis);
+
+    planBuilder =
+        planBuilder.planHavingAndTransform(
+            analysis.getHavingExpression(),
+            analysis.getSelectExpressions(),
+            analysis.getOrderByExpressions(),
+            queryStatement.isGroupByTime(),
+            queryStatement.getResultTimeOrder());
+
+    if (!queryStatement.needPushDownSort()) {
+      planBuilder = planBuilder.planOrderBy(queryStatement, analysis);
+    }
+
+    planBuilder =
+        planBuilder
+            .planFill(analysis.getFillDescriptor(), queryStatement.getResultTimeOrder())
+            .planOffset(queryStatement.getRowOffset());
+
+    if (!analysis.isUseTopKNode() || queryStatement.hasOffset()) {
+      planBuilder = planBuilder.planLimit(queryStatement.getRowLimit());
+    }
+
+    return planBuilder.getRoot();
+  }
+
   public PlanNode visitQueryBody(PartialPath devicePath) {
 
     TemplatedLogicalPlanBuilder planBuilder =
@@ -213,4 +325,53 @@ public PlanNode visitQueryBody(PartialPath devicePath) {
 
     return planBuilder.getRoot();
   }
+
+  private PlanNode visitDeviceAggregationBody(PartialPath devicePath) {
+    TemplatedLogicalPlanBuilder planBuilder =
+        new TemplatedLogicalPlanBuilder(analysis, context, newMeasurementList, newSchemaList);
+
+    planBuilder =
+        planBuilder
+            .planRawDataSource(
+                devicePath,
+                queryStatement.getResultTimeOrder(),
+                OFFSET_VALUE,
+                limitValue,
+                analysis.isLastLevelUseWildcard())
+            .planFilter(
+                whereExpression,
+                queryStatement.isGroupByTime(),
+                queryStatement.getResultTimeOrder());
+
+    boolean outputPartial =
+        queryStatement.isGroupByLevel()
+            || queryStatement.isGroupByTag()
+            || (queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap());
+    AggregationStep curStep = outputPartial ? AggregationStep.PARTIAL : AggregationStep.SINGLE;
+    planBuilder =
+        planBuilder.planRawDataAggregation(
+            analysis.getSelectExpressions(),
+            null,
+            analysis.getGroupByTimeParameter(),
+            analysis.getGroupByParameter(),
+            queryStatement.isOutputEndTime(),
+            curStep,
+            queryStatement.getResultTimeOrder());
+
+    if (queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap()) {
+      curStep =
+          (queryStatement.isGroupByLevel() || queryStatement.isGroupByTag())
+              ? AggregationStep.INTERMEDIATE
+              : AggregationStep.FINAL;
+      planBuilder =
+          planBuilder.planSlidingWindowAggregation(
+              analysis.getSelectExpressions(),
+              analysis.getGroupByTimeParameter(),
+              curStep,
+              queryStatement.getResultTimeOrder());
+    }
+
+    // no group by level and group by tag
+    return planBuilder.getRoot();
+  }
 }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
index fb6b2ea04c85..4942c76e3082 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
@@ -27,14 +27,20 @@
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.FilterNode;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.RawDataAggregationNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.AlignedSeriesScanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.SeriesScanNode;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationDescriptor;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationStep;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.GroupByParameter;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.GroupByTimeParameter;
 import org.apache.iotdb.db.queryengine.plan.statement.component.Ordering;
 
 import org.apache.tsfile.write.schema.IMeasurementSchema;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
 
 /**
  * This class provides accelerated implementation for multiple devices align by device query. This
@@ -126,6 +132,55 @@ public TemplatedLogicalPlanBuilder planFilter(
     return this;
   }
 
+  public TemplatedLogicalPlanBuilder planRawDataAggregation(
+      Set<Expression> aggregationExpressions,
+      Expression groupByExpression,
+      GroupByTimeParameter groupByTimeParameter,
+      GroupByParameter groupByParameter,
+      boolean outputEndTime,
+      AggregationStep curStep,
+      Ordering scanOrder) {
+    if (aggregationExpressions == null) {
+      return this;
+    }
+
+    List<AggregationDescriptor> aggregationDescriptorList =
+        constructAggregationDescriptorList(aggregationExpressions, curStep);
+    updateTypeProvider(aggregationExpressions);
+    if (curStep.isOutputPartial()) {
+      aggregationDescriptorList.forEach(
+          aggregationDescriptor ->
+              updateTypeProviderByPartialAggregation(
+                  aggregationDescriptor, context.getTypeProvider()));
+    }
+    this.root =
+        new RawDataAggregationNode(
+            context.getQueryId().genPlanNodeId(),
+            this.getRoot(),
+            aggregationDescriptorList,
+            groupByTimeParameter,
+            groupByParameter,
+            groupByExpression,
+            outputEndTime,
+            scanOrder);
+    return this;
+  }
+
+  public TemplatedLogicalPlanBuilder planSlidingWindowAggregation(
+      Set<Expression> aggregationExpressions,
+      GroupByTimeParameter groupByTimeParameter,
+      AggregationStep curStep,
+      Ordering scanOrder) {
+    if (aggregationExpressions == null) {
+      return this;
+    }
+
+    this.root =
+        createSlidingWindowAggregationNode(
+            this.getRoot(), aggregationExpressions, groupByTimeParameter, curStep, scanOrder);
+    return this;
+  }
+
   @Override
   public TemplatedLogicalPlanBuilder withNewRoot(PlanNode newRoot) {
     this.root = newRoot;

From 304f68f1a5baef1caffa041452ad260c0e019e5c Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Sat, 11 May 2024 19:27:43 +0800
Subject: [PATCH 02/28] add select max_time(s1), last_value(s1), last_value(s2)
 impl

---
 .../db/queryengine/plan/analyze/Analysis.java |   3 +-
 .../plan/analyze/ExpressionTypeAnalyzer.java  |  14 +-
 .../analyze/TemplatedAggregationAnalyze.java  |  91 ++++++++---
 .../plan/analyze/TemplatedInfo.java           |  22 ++-
 .../optimization/AggregationPushDown.java     | 132 ++++++++++++++--
 .../plan/planner/OperatorTreeGenerator.java   |  66 ++++++--
 .../plan/planner/TemplatedLogicalPlan.java    | 141 +++++++++++++-----
 .../planner/TemplatedLogicalPlanBuilder.java  |  15 +-
 .../plan/parameter/AggregationDescriptor.java |   2 +-
 9 files changed, 390 insertions(+), 96 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java
index d7e2163eca1b..3a58adc130ed 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java
@@ -409,7 +409,8 @@ public TSDataType getType(Expression expression) {
     }
 
     if (isAllDevicesInOneTemplate()
-        && (isOnlyQueryTemplateMeasurements() || expression instanceof TimeSeriesOperand)) {
+        && isOnlyQueryTemplateMeasurements()
+        && expression instanceof TimeSeriesOperand) {
       TimeSeriesOperand seriesOperand = (TimeSeriesOperand) expression;
       return deviceTemplate.getSchemaMap().get(seriesOperand.getPath().getMeasurement()).getType();
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
index 49904d6532cc..1cd7fbcf8367 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
@@ -19,6 +19,7 @@
 
 package org.apache.iotdb.db.queryengine.plan.analyze;
 
+import org.apache.iotdb.commons.path.MeasurementPath;
 import org.apache.iotdb.db.exception.sql.SemanticException;
 import org.apache.iotdb.db.queryengine.common.NodeRef;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
@@ -65,7 +66,10 @@ private ExpressionTypeAnalyzer() {}
   public static TSDataType analyzeExpression(Analysis analysis, Expression expression) {
     if (!analysis.getExpressionTypes().containsKey(NodeRef.of(expression))) {
       ExpressionTypeAnalyzer analyzer = new ExpressionTypeAnalyzer();
-      analyzer.analyze(expression, null);
+
+      Map<String, IMeasurementSchema> context =
+          analysis.isAllDevicesInOneTemplate() ? analysis.getDeviceTemplate().getSchemaMap() : null;
+      analyzer.analyze(expression, context);
 
       addExpressionTypes(analysis, analyzer);
     }
@@ -346,6 +350,14 @@ public TSDataType visitTimeSeriesOperand(
         return setExpressionType(
             timeSeriesOperand, context.get(timeSeriesOperand.getOutputSymbol()).getType());
       }
+
+      if (context != null
+          && !(timeSeriesOperand.getPath() instanceof MeasurementPath)
+          && context.containsKey(timeSeriesOperand.getPath().getFullPath())) {
+        return setExpressionType(
+            timeSeriesOperand, context.get(timeSeriesOperand.getPath().getFullPath()).getType());
+      }
+
       return setExpressionType(timeSeriesOperand, timeSeriesOperand.getPath().getSeriesType());
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index ae2afa9c8f56..60211412341d 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -1,3 +1,21 @@
+/*
+ * 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.iotdb.db.queryengine.plan.analyze;
 
 import org.apache.iotdb.commons.path.PartialPath;
@@ -10,13 +28,17 @@
 import org.apache.iotdb.db.schemaengine.template.Template;
 
 import org.apache.tsfile.utils.Pair;
+import org.apache.tsfile.write.schema.IMeasurementSchema;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
 
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.DEVICE_EXPRESSION;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.END_TIME_EXPRESSION;
+import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeExpressionType;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeOutput;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDataPartition;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDeviceToWhere;
@@ -26,10 +48,9 @@
 import static org.apache.iotdb.db.queryengine.plan.optimization.LimitOffsetPushDown.canPushDownLimitOffsetInGroupByTimeForDevice;
 import static org.apache.iotdb.db.queryengine.plan.optimization.LimitOffsetPushDown.pushDownLimitOffsetInGroupByTimeForDevice;
 
+/** Methods in this class are used for aggregation, templated with align by device situation. */
 public class TemplatedAggregationAnalyze {
 
-  // ----------- Methods below are used for aggregation, templated with align by device --------
-
   static boolean analyzeAggregation(
       Analysis analysis,
       QueryStatement queryStatement,
@@ -45,6 +66,9 @@ static boolean analyzeAggregation(
       deviceList = pushDownLimitOffsetInGroupByTimeForDevice(deviceList, queryStatement);
     }
 
+    List<Pair<Expression, String>> outputExpressions = new ArrayList<>();
+    analyzeSelect(queryStatement, analysis, outputExpressions, template);
+
     analyzeDeviceToWhere(analysis, queryStatement);
     if (deviceList.isEmpty()) {
       analysis.setFinishQueryAfterAnalyze(true);
@@ -52,15 +76,8 @@ static boolean analyzeAggregation(
     }
     analysis.setDeviceList(deviceList);
 
-    List<Pair<Expression, String>> outputExpressions = new ArrayList<>();
-    ColumnPaginationController paginationController =
-        new ColumnPaginationController(
-            queryStatement.getSeriesLimit(), queryStatement.getSeriesOffset());
-    for (ResultColumn resultColumn : queryStatement.getSelectComponent().getResultColumns()) {}
-
-    analyzeSelect(queryStatement, analysis, outputExpressions, template);
     if (analysis.getWhereExpression() != null
-        && analysis.getWhereExpression().equals(ConstantOperand.FALSE)) {
+        && ConstantOperand.FALSE.equals(analysis.getWhereExpression())) {
       analyzeOutput(analysis, queryStatement, outputExpressions);
       analysis.setFinishQueryAfterAnalyze(true);
       return true;
@@ -87,21 +104,61 @@ private static void analyzeSelect(
       Analysis analysis,
       List<Pair<Expression, String>> outputExpressions,
       Template template) {
+
     LinkedHashSet<Expression> selectExpressions = new LinkedHashSet<>();
     selectExpressions.add(DEVICE_EXPRESSION);
     if (queryStatement.isOutputEndTime()) {
       selectExpressions.add(END_TIME_EXPRESSION);
     }
-    for (Pair<Expression, String> pair : outputExpressions) {
-      Expression selectExpression = pair.left;
-      selectExpressions.add(selectExpression);
+
+    ColumnPaginationController paginationController =
+        new ColumnPaginationController(
+            queryStatement.getSeriesLimit(), queryStatement.getSeriesOffset());
+
+    Set<Expression> aggregationExpressions = new LinkedHashSet<>();
+    for (ResultColumn resultColumn : queryStatement.getSelectComponent().getResultColumns()) {
+      if (paginationController.hasCurOffset()) {
+        paginationController.consumeOffset();
+      } else if (paginationController.hasCurLimit()) {
+        Expression selectExpression = resultColumn.getExpression();
+        outputExpressions.add(new Pair<>(selectExpression, resultColumn.getAlias()));
+        selectExpressions.add(selectExpression);
+        aggregationExpressions.add(selectExpression);
+      } else {
+        break;
+      }
     }
+
+    analysis.setDeviceTemplate(template);
+    List<String> measurementList = new ArrayList<>();
+    List<IMeasurementSchema> measurementSchemaList = new ArrayList<>();
+    Set<String> measurementSet = new HashSet<>();
+    for (Expression selectExpression : selectExpressions) {
+      if ("device".equalsIgnoreCase(selectExpression.getOutputSymbol())) {
+        continue;
+      }
+
+      String measurement = selectExpression.getExpressions().get(0).getOutputSymbol();
+      if (!template.getSchemaMap().containsKey(measurement)) {
+        throw new IllegalArgumentException(
+            "Measurement " + measurement + " is not found in template");
+      }
+
+      // for agg1(s1) + agg2(s1), only record s1 for one time
+      if (!measurementSet.contains(measurement)) {
+        measurementSet.add(measurement);
+        measurementList.add(measurement);
+        measurementSchemaList.add(template.getSchemaMap().get(measurement));
+      }
+
+      analyzeExpressionType(analysis, selectExpression);
+    }
+
+    analysis.setMeasurementList(measurementList);
+    analysis.setMeasurementSchemaList(measurementSchemaList);
+    analysis.setAggregationExpressions(aggregationExpressions);
     analysis.setOutputExpressions(outputExpressions);
     analysis.setSelectExpressions(selectExpressions);
-    analysis.setDeviceTemplate(template);
-    // TODO only add measurement and schema occured in selectExpressions
-    analysis.setMeasurementList(new ArrayList<>(template.getSchemaMap().keySet()));
-    analysis.setMeasurementSchemaList(new ArrayList<>(template.getSchemaMap().values()));
   }
 
   private static void analyzeDeviceToSourceTransform(Analysis analysis) {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
index bf5d54e5cd62..f042c36a07d2 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
@@ -23,6 +23,8 @@
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimeSeriesOperand;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationDescriptor;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.GroupByTimeParameter;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.InputLocation;
 import org.apache.iotdb.db.queryengine.plan.statement.component.Ordering;
 
@@ -76,10 +78,15 @@ public class TemplatedInfo {
   private int maxTsBlockLineNum = -1;
 
   // variables related to predicate push down
+  // TODO when to init pushDownPredicate in agg situation?
   private Expression pushDownPredicate;
 
-  private Set<Expression> aggSelectExpressions;
+  // variables related to aggregation
+  public List<AggregationDescriptor> aggregationDescriptorList;
+  public GroupByTimeParameter groupByTimeParameter;
+  public boolean outputEndTime = false;
 
+  private Set<Expression> aggSelectExpressions;
   private Expression havingExpression;
 
   public TemplatedInfo(
@@ -96,7 +103,9 @@ public TemplatedInfo(
       boolean keepNull,
       Map<String, IMeasurementSchema> schemaMap,
       Map<String, List<InputLocation>> layoutMap,
-      Expression pushDownPredicate) {
+      Expression pushDownPredicate,
+      GroupByTimeParameter groupByTimeParameter,
+      boolean outputEndTime) {
     this.measurementList = measurementList;
     this.schemaList = schemaList;
     this.dataTypes = dataTypes;
@@ -113,6 +122,9 @@ public TemplatedInfo(
       this.layoutMap = layoutMap;
     }
     this.pushDownPredicate = pushDownPredicate;
+
+    this.groupByTimeParameter = groupByTimeParameter;
+    this.outputEndTime = outputEndTime;
   }
 
   public List<String> getMeasurementList() {
@@ -355,6 +367,8 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
       pushDownPredicate = Expression.deserialize(byteBuffer);
     }
 
+    // TODO add groupByTimeParameter, outputEndTime serialization and deserialization
+
     return new TemplatedInfo(
         measurementList,
         measurementSchemaList,
@@ -369,6 +383,8 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
         keepNull,
         currentSchemaMap,
         layoutMap,
-        pushDownPredicate);
+        pushDownPredicate,
+        null,
+        false);
   }
 }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index 344572be2b36..ec1d2fdb09ad 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -63,11 +63,13 @@
 import org.apache.tsfile.write.schema.IMeasurementSchema;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import static com.google.common.base.Preconditions.checkState;
 import static org.apache.iotdb.db.utils.constant.SqlConstant.COUNT_TIME;
@@ -92,6 +94,12 @@ public PlanNode optimize(PlanNode plan, Analysis analysis, MPPQueryContext conte
   private boolean cannotUseStatistics(QueryStatement queryStatement, Analysis analysis) {
     boolean isAlignByDevice = queryStatement.isAlignByDevice();
     if (isAlignByDevice) {
+      if (analysis.isAllDevicesInOneTemplate()) {
+        // TODO agg+template situation, how about the SourceTransformExpressions
+        return cannotUseStatistics(
+            analysis.getAggregationExpressions(), analysis.getAggregationExpressions());
+      }
+
       // check any of the devices
       String device = analysis.getDeviceList().get(0).toString();
       return cannotUseStatistics(
@@ -172,6 +180,10 @@ public PlanNode visitDeviceView(DeviceViewNode node, RewriterContext context) {
       List<PlanNode> rewrittenChildren = new ArrayList<>();
       for (int i = 0; i < node.getDevices().size(); i++) {
         context.setCurDevice(node.getDevices().get(i));
+        if (context.analysis.isAllDevicesInOneTemplate()) {
+          context.setCurDevicePath(context.analysis.getDeviceList().get(i));
+        }
+
         rewrittenChildren.add(node.getChildren().get(i).accept(this, context));
       }
       node.setChildren(rewrittenChildren);
@@ -257,14 +269,26 @@ public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterCon
               sourceToCountTimeAggregationsMap);
         }
 
-        List<PlanNode> sourceNodeList =
-            constructSourceNodeFromAggregationDescriptors(
-                sourceToAscendingAggregationsMap,
-                sourceToDescendingAggregationsMap,
-                sourceToCountTimeAggregationsMap,
-                node.getScanOrder(),
-                node.getGroupByTimeParameter(),
-                context);
+        List<PlanNode> sourceNodeList;
+        if (context.analysis.isAllDevicesInOneTemplate()) {
+          sourceNodeList =
+              constructSourceNodeFromTemplateAggregationDescriptors(
+                  sourceToAscendingAggregationsMap,
+                  sourceToDescendingAggregationsMap,
+                  sourceToCountTimeAggregationsMap,
+                  node.getScanOrder(),
+                  node.getGroupByTimeParameter(),
+                  context);
+        } else {
+          sourceNodeList =
+              constructSourceNodeFromAggregationDescriptors(
+                  sourceToAscendingAggregationsMap,
+                  sourceToDescendingAggregationsMap,
+                  sourceToCountTimeAggregationsMap,
+                  node.getScanOrder(),
+                  node.getGroupByTimeParameter(),
+                  context);
+        }
 
         if (isSingleSource && ((SeriesScanSourceNode) child).getPushDownPredicate() != null) {
           Expression pushDownPredicate = ((SeriesScanSourceNode) child).getPushDownPredicate();
@@ -352,7 +376,6 @@ private List<PlanNode> constructSourceNodeFromAggregationDescriptors(
         GroupByTimeParameter groupByTimeParameter,
         RewriterContext context) {
       List<PlanNode> sourceNodeList = new ArrayList<>();
-      boolean needCheckAscending = groupByTimeParameter == null;
       Map<PartialPath, List<AggregationDescriptor>> groupedAscendingAggregations = null;
       if (!countTimeAggregations.isEmpty()) {
         groupedAscendingAggregations = countTimeAggregations;
@@ -371,6 +394,7 @@ private List<PlanNode> constructSourceNodeFromAggregationDescriptors(
                 context));
       }
 
+      boolean needCheckAscending = groupByTimeParameter == null;
       if (needCheckAscending) {
         Map<PartialPath, List<AggregationDescriptor>> groupedDescendingAggregations =
             MetaUtils.groupAlignedAggregations(descendingAggregations);
@@ -388,6 +412,85 @@ private List<PlanNode> constructSourceNodeFromAggregationDescriptors(
       return sourceNodeList;
     }
 
+    private List<PlanNode> constructSourceNodeFromTemplateAggregationDescriptors(
+        Map<PartialPath, List<AggregationDescriptor>> ascendingAggregations,
+        Map<PartialPath, List<AggregationDescriptor>> descendingAggregations,
+        Map<PartialPath, List<AggregationDescriptor>> countTimeAggregations,
+        Ordering scanOrder,
+        GroupByTimeParameter groupByTimeParameter,
+        RewriterContext context) {
+
+      // keySet of ascendingAggregations is measurement,
+      // valueSet of ascendingAggregations is aggDescriptors such as count(s1), avg(s1)
+
+      List<PlanNode> sourceNodeList = new ArrayList<>();
+      PartialPath devicePath = context.curDevicePath;
+      List<String> measurementList = context.analysis.getMeasurementList();
+      List<IMeasurementSchema> measurementSchemaList = context.analysis.getMeasurementSchemaList();
+      boolean needCheckAscending = groupByTimeParameter == null;
+
+      if (context.analysis.getDeviceTemplate().isDirectAligned()) {
+        AlignedPath alignedPath = new AlignedPath(devicePath);
+        alignedPath.setMeasurementList(measurementList);
+        alignedPath.addSchemas(measurementSchemaList);
+
+        List<AggregationDescriptor> aggregationDescriptors =
+            ascendingAggregations.values().stream()
+                .flatMap(Collection::stream)
+                .collect(Collectors.toList());
+        if (!aggregationDescriptors.isEmpty()) {
+          sourceNodeList.add(
+              createAggregationScanNode(
+                  alignedPath, aggregationDescriptors, scanOrder, groupByTimeParameter, context));
+        }
+
+        if (needCheckAscending) {
+          aggregationDescriptors =
+              descendingAggregations.values().stream()
+                  .flatMap(Collection::stream)
+                  .collect(Collectors.toList());
+          sourceNodeList.add(
+              createAggregationScanNode(
+                  alignedPath, aggregationDescriptors, scanOrder, groupByTimeParameter, context));
+        }
+      } else {
+        // TODO verify the rightness of non-aligned series
+        for (int i = 0; i < measurementList.size(); i++) {
+          MeasurementPath measurementPath =
+              new MeasurementPath(
+                  devicePath.concatNode(measurementList.get(i)), measurementSchemaList.get(i));
+          for (List<AggregationDescriptor> aggregationDescriptorList :
+              descendingAggregations.values()) {
+            sourceNodeList.add(
+                createAggregationScanNode(
+                    measurementPath,
+                    aggregationDescriptorList,
+                    scanOrder,
+                    groupByTimeParameter,
+                    context));
+          }
+
+          if (needCheckAscending) {
+            for (List<AggregationDescriptor> aggregationDescriptorList :
+                descendingAggregations.values()) {
+              sourceNodeList.add(
+                  createAggregationScanNode(
+                      measurementPath,
+                      aggregationDescriptorList,
+                      scanOrder,
+                      groupByTimeParameter,
+                      context));
+            }
+          }
+        }
+      }
+
+      // TODO count(s1+s2) is not supported
+      // TODO count_time is not supported
+
+      return sourceNodeList;
+    }
+
     private SeriesAggregationSourceNode createAggregationScanNode(
         PartialPath selectPath,
         List<AggregationDescriptor> aggregationDescriptorList,
@@ -442,6 +545,7 @@ private static class RewriterContext {
     private final boolean isAlignByDevice;
 
     private String curDevice;
+    private PartialPath curDevicePath;
 
     public RewriterContext(Analysis analysis, MPPQueryContext context, boolean isAlignByDevice) {
       this.analysis = analysis;
@@ -461,9 +565,17 @@ public void setCurDevice(String curDevice) {
       this.curDevice = curDevice;
     }
 
+    public void setCurDevicePath(PartialPath devicePath) {
+      this.curDevicePath = devicePath;
+    }
+
     public Set<Expression> getAggregationExpressions() {
       if (isAlignByDevice) {
-        return analysis.getDeviceToAggregationExpressions().get(curDevice);
+        if (analysis.isAllDevicesInOneTemplate()) {
+          return analysis.getAggregationExpressions();
+        } else {
+          return analysis.getDeviceToAggregationExpressions().get(curDevice);
+        }
       }
       return analysis.getAggregationExpressions();
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
index c271e8ec2da3..1783480abb89 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
@@ -591,28 +591,62 @@ public Operator visitSeriesAggregationScan(
   @Override
   public Operator visitAlignedSeriesAggregationScan(
       AlignedSeriesAggregationScanNode node, LocalExecutionPlanContext context) {
-    AlignedPath seriesPath = node.getAlignedPath();
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    if (context.isBuildPlanUseTemplate()) {
+      return constructAlignedSeriesAggregationScanOperator(
+          node.getPlanNodeId(),
+          node.getAlignedPath(),
+          context.getTemplatedInfo().aggregationDescriptorList,
+          context.getTemplatedInfo().getPushDownPredicate(),
+          context.getTemplatedInfo().getScanOrder(),
+          context.getTemplatedInfo().groupByTimeParameter,
+          context.getTemplatedInfo().outputEndTime,
+          context);
+    }
+
+    return constructAlignedSeriesAggregationScanOperator(
+        node.getPlanNodeId(),
+        node.getAlignedPath(),
+        node.getAggregationDescriptorList(),
+        node.getPushDownPredicate(),
+        node.getScanOrder(),
+        node.getGroupByTimeParameter(),
+        node.isOutputEndTime(),
+        context);
+  }
+
+  private Operator constructAlignedSeriesAggregationScanOperator(
+      PlanNodeId planNodeId,
+      AlignedPath alignedPath,
+      List<AggregationDescriptor> aggregationDescriptorList,
+      Expression pushDownPredicate,
+      Ordering scanOrder,
+      GroupByTimeParameter groupByTimeParameter,
+      boolean outputEndTime,
+      LocalExecutionPlanContext context) {
+    boolean ascending = scanOrder == Ordering.ASC;
     List<Aggregator> aggregators = new ArrayList<>();
-    for (AggregationDescriptor descriptor : node.getAggregationDescriptorList()) {
+    for (AggregationDescriptor descriptor : aggregationDescriptorList) {
       checkArgument(
           descriptor.getInputExpressions().size() == 1,
           "descriptor's input expression size is not 1");
+
       Expression expression = descriptor.getInputExpressions().get(0);
       if (expression instanceof TimeSeriesOperand) {
+        // TODO for template_agg, no need use getPath.getMeasurement
         String inputSeries =
             ((TimeSeriesOperand) (descriptor.getInputExpressions().get(0)))
                 .getPath()
                 .getMeasurement();
-        int seriesIndex = seriesPath.getMeasurementList().indexOf(inputSeries);
+        int seriesIndex = alignedPath.getMeasurementList().indexOf(inputSeries);
         TSDataType seriesDataType =
-            seriesPath.getMeasurementSchema().getSubMeasurementsTSDataTypeList().get(seriesIndex);
+            alignedPath.getMeasurementSchema().getSubMeasurementsTSDataTypeList().get(seriesIndex);
         aggregators.add(
             new Aggregator(
                 AccumulatorFactory.createAccumulator(
                     descriptor.getAggregationFuncName(),
                     descriptor.getAggregationType(),
                     Collections.singletonList(seriesDataType),
+                    // TODO inputExpression must be devicePath+measurement
                     descriptor.getInputExpressions(),
                     descriptor.getInputAttributes(),
                     ascending,
@@ -627,6 +661,7 @@ public Operator visitAlignedSeriesAggregationScan(
                     descriptor.getAggregationFuncName(),
                     descriptor.getAggregationType(),
                     Collections.singletonList(TSDataType.INT64),
+                    // TODO inputExpression must be devicePath+measurement
                     descriptor.getInputExpressions(),
                     descriptor.getInputAttributes(),
                     ascending,
@@ -640,23 +675,22 @@ public Operator visitAlignedSeriesAggregationScan(
       }
     }
 
-    GroupByTimeParameter groupByTimeParameter = node.getGroupByTimeParameter();
     ITimeRangeIterator timeRangeIterator =
         initTimeRangeIterator(groupByTimeParameter, ascending, true);
     long maxReturnSize =
         AggregationUtil.calculateMaxAggregationResultSize(
-            node.getAggregationDescriptorList(), timeRangeIterator, context.getTypeProvider());
+            aggregationDescriptorList, timeRangeIterator, context.getTypeProvider());
 
     SeriesScanOptions.Builder scanOptionsBuilder = getSeriesScanOptionsBuilder(context);
-    scanOptionsBuilder.withAllSensors(new HashSet<>(seriesPath.getMeasurementList()));
+    scanOptionsBuilder.withAllSensors(new HashSet<>(alignedPath.getMeasurementList()));
 
-    Expression pushDownPredicate = node.getPushDownPredicate();
     if (pushDownPredicate != null) {
       checkArgument(PredicateUtils.predicateCanPushIntoScan(pushDownPredicate));
       scanOptionsBuilder.withPushDownFilter(
           convertPredicateToFilter(
               pushDownPredicate,
-              node.getAlignedPath().getMeasurementList(),
+              alignedPath.getMeasurementList(),
+              // TODO what's the meaning of isBuildPlanUseTemplate
               context.getTypeProvider().getTemplatedInfo() != null,
               context.getTypeProvider()));
     }
@@ -666,14 +700,14 @@ public Operator visitAlignedSeriesAggregationScan(
             .getDriverContext()
             .addOperatorContext(
                 context.getNextOperatorId(),
-                node.getPlanNodeId(),
+                planNodeId,
                 AlignedSeriesAggregationScanOperator.class.getSimpleName());
     AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
         new AlignedSeriesAggregationScanOperator(
-            node.getPlanNodeId(),
-            seriesPath,
-            node.getScanOrder(),
-            node.isOutputEndTime(),
+            planNodeId,
+            alignedPath,
+            scanOrder,
+            outputEndTime,
             scanOptionsBuilder.build(),
             operatorContext,
             aggregators,
@@ -683,7 +717,7 @@ public Operator visitAlignedSeriesAggregationScan(
 
     ((DataDriverContext) context.getDriverContext())
         .addSourceOperator(seriesAggregationScanOperator);
-    ((DataDriverContext) context.getDriverContext()).addPath(seriesPath);
+    ((DataDriverContext) context.getDriverContext()).addPath(alignedPath);
     context.getDriverContext().setInputDriver(true);
     return seriesAggregationScanOperator;
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
index 7bb9ebd579ca..6117e8795d96 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
@@ -25,14 +25,19 @@
 import org.apache.iotdb.db.queryengine.plan.analyze.TemplatedInfo;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimeSeriesOperand;
+import org.apache.iotdb.db.queryengine.plan.expression.multi.FunctionExpression;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationDescriptor;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationStep;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.InputLocation;
 import org.apache.iotdb.db.queryengine.plan.statement.crud.QueryStatement;
 
+import org.apache.commons.lang3.Validate;
+import org.apache.tsfile.enums.TSDataType;
 import org.apache.tsfile.write.schema.IMeasurementSchema;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -40,8 +45,11 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import static org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant.DEVICE;
+import static org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant.ENDTIME;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.searchSourceExpressions;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedInfo.makeLayout;
+import static org.apache.iotdb.db.queryengine.plan.planner.LogicalPlanBuilder.updateTypeProviderByPartialAggregation;
 import static org.apache.iotdb.db.queryengine.plan.planner.LogicalPlanVisitor.pushDownLimitToScanNode;
 
 /**
@@ -71,6 +79,8 @@ public class TemplatedLogicalPlan {
 
   private Map<String, List<InputLocation>> filterLayoutMap;
 
+  List<AggregationDescriptor> aggregationDescriptorList;
+
   public TemplatedLogicalPlan(
       Analysis analysis, QueryStatement queryStatement, MPPQueryContext context) {
     this.analysis = analysis;
@@ -144,7 +154,9 @@ private void initAggQueryCommonVariables() {
                 queryStatement.isGroupByTime(),
                 analysis.getDeviceTemplate().getSchemaMap(),
                 filterLayoutMap,
-                null));
+                null,
+                analysis.getGroupByTimeParameter(),
+                queryStatement.isOutputEndTime()));
   }
 
   private void initNonAggQueryCommonVariables() {
@@ -199,7 +211,9 @@ private void initNonAggQueryCommonVariables() {
                 queryStatement.isGroupByTime(),
                 analysis.getDeviceTemplate().getSchemaMap(),
                 filterLayoutMap,
-                null));
+                null,
+                analysis.getGroupByTimeParameter(),
+                queryStatement.isOutputEndTime()));
   }
 
   public PlanNode visitQuery() {
@@ -255,14 +269,62 @@ public PlanNode visitQuery() {
     return planBuilder.getRoot();
   }
 
+  public PlanNode visitQueryBody(PartialPath devicePath) {
+
+    TemplatedLogicalPlanBuilder planBuilder =
+        new TemplatedLogicalPlanBuilder(analysis, context, newMeasurementList, newSchemaList);
+
+    planBuilder =
+        planBuilder
+            .planRawDataSource(
+                devicePath,
+                queryStatement.getResultTimeOrder(),
+                OFFSET_VALUE,
+                limitValue,
+                analysis.isLastLevelUseWildcard())
+            .planFilter(
+                whereExpression,
+                queryStatement.isGroupByTime(),
+                queryStatement.getResultTimeOrder());
+
+    return planBuilder.getRoot();
+  }
+
+  // ============== Methods below are used for templated aggregation ======================
+
   private PlanNode visitAggregation() {
+    boolean outputPartial =
+        queryStatement.isGroupByLevel()
+            || queryStatement.isGroupByTag()
+            || (queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap());
+    AggregationStep curStep = outputPartial ? AggregationStep.PARTIAL : AggregationStep.SINGLE;
+
+    if (queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap()) {
+      curStep =
+          (queryStatement.isGroupByLevel() || queryStatement.isGroupByTag())
+              ? AggregationStep.INTERMEDIATE
+              : AggregationStep.FINAL;
+    }
+
+    aggregationDescriptorList =
+        constructAggregationDescriptorList(analysis.getAggregationExpressions(), curStep);
+    updateTypeProvider(analysis.getAggregationExpressions());
+    if (curStep.isOutputPartial()) {
+      aggregationDescriptorList.forEach(
+          aggregationDescriptor ->
+              updateTypeProviderByPartialAggregation(
+                  aggregationDescriptor, context.getTypeProvider()));
+    }
+
+    context.getTypeProvider().getTemplatedInfo().aggregationDescriptorList =
+        aggregationDescriptorList;
+
     LogicalPlanBuilder planBuilder =
         new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList);
-
     Map<String, PlanNode> deviceToSubPlanMap = new LinkedHashMap<>();
     for (PartialPath devicePath : analysis.getDeviceList()) {
       String deviceName = devicePath.getFullPath();
-      PlanNode rootNode = visitDeviceAggregationBody(devicePath);
+      PlanNode rootNode = visitDeviceAggregationBody(devicePath, curStep);
 
       LogicalPlanBuilder subPlanBuilder =
           new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList)
@@ -305,28 +367,7 @@ private PlanNode visitAggregation() {
     return planBuilder.getRoot();
   }
 
-  public PlanNode visitQueryBody(PartialPath devicePath) {
-
-    TemplatedLogicalPlanBuilder planBuilder =
-        new TemplatedLogicalPlanBuilder(analysis, context, newMeasurementList, newSchemaList);
-
-    planBuilder =
-        planBuilder
-            .planRawDataSource(
-                devicePath,
-                queryStatement.getResultTimeOrder(),
-                OFFSET_VALUE,
-                limitValue,
-                analysis.isLastLevelUseWildcard())
-            .planFilter(
-                whereExpression,
-                queryStatement.isGroupByTime(),
-                queryStatement.getResultTimeOrder());
-
-    return planBuilder.getRoot();
-  }
-
-  private PlanNode visitDeviceAggregationBody(PartialPath devicePath) {
+  private PlanNode visitDeviceAggregationBody(PartialPath devicePath, AggregationStep curStep) {
     TemplatedLogicalPlanBuilder planBuilder =
         new TemplatedLogicalPlanBuilder(analysis, context, newMeasurementList, newSchemaList);
 
@@ -343,26 +384,18 @@ private PlanNode visitDeviceAggregationBody(PartialPath devicePath) {
                 queryStatement.isGroupByTime(),
                 queryStatement.getResultTimeOrder());
 
-    boolean outputPartial =
-        queryStatement.isGroupByLevel()
-            || queryStatement.isGroupByTag()
-            || (queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap());
-    AggregationStep curStep = outputPartial ? AggregationStep.PARTIAL : AggregationStep.SINGLE;
     planBuilder =
         planBuilder.planRawDataAggregation(
-            analysis.getSelectExpressions(),
+            analysis.getAggregationExpressions(),
             null,
             analysis.getGroupByTimeParameter(),
             analysis.getGroupByParameter(),
             queryStatement.isOutputEndTime(),
             curStep,
-            queryStatement.getResultTimeOrder());
+            queryStatement.getResultTimeOrder(),
+            aggregationDescriptorList);
 
     if (queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap()) {
-      curStep =
-          (queryStatement.isGroupByLevel() || queryStatement.isGroupByTag())
-              ? AggregationStep.INTERMEDIATE
-              : AggregationStep.FINAL;
       planBuilder =
           planBuilder.planSlidingWindowAggregation(
               analysis.getSelectExpressions(),
@@ -374,4 +407,38 @@ private PlanNode visitDeviceAggregationBody(PartialPath devicePath) {
     // no group by level and group by tag
     return planBuilder.getRoot();
   }
+
+  private List<AggregationDescriptor> constructAggregationDescriptorList(
+      Set<Expression> aggregationExpressions, AggregationStep curStep) {
+    return aggregationExpressions.stream()
+        .map(
+            expression -> {
+              Validate.isTrue(expression instanceof FunctionExpression);
+              return new AggregationDescriptor(
+                  ((FunctionExpression) expression).getFunctionName(),
+                  curStep,
+                  expression.getExpressions(),
+                  ((FunctionExpression) expression).getFunctionAttributes());
+            })
+        .collect(Collectors.toList());
+  }
+
+  void updateTypeProvider(Collection<Expression> expressions) {
+    if (expressions == null) {
+      return;
+    }
+    expressions.forEach(
+        expression -> {
+          if (!expression.getExpressionString().equals(DEVICE)
+              && !expression.getExpressionString().equals(ENDTIME)) {
+            context
+                .getTypeProvider()
+                .setType(expression.getExpressionString(), getPreAnalyzedType(expression));
+          }
+        });
+  }
+
+  private TSDataType getPreAnalyzedType(Expression expression) {
+    return analysis.getType(expression);
+  }
 }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
index 4942c76e3082..6ef95f0e1196 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
@@ -48,6 +48,7 @@
  * unnecessary judgements.
  */
 public class TemplatedLogicalPlanBuilder extends LogicalPlanBuilder {
+
   private final MPPQueryContext context;
 
   private final Analysis analysis;
@@ -132,6 +133,8 @@ public TemplatedLogicalPlanBuilder planFilter(
     return this;
   }
 
+  // ===================== Methods below are used for aggregation =============================
+
   public TemplatedLogicalPlanBuilder planRawDataAggregation(
       Set<Expression> aggregationExpressions,
       Expression groupByExpression,
@@ -139,20 +142,12 @@ public TemplatedLogicalPlanBuilder planRawDataAggregation(
       GroupByParameter groupByParameter,
       boolean outputEndTime,
       AggregationStep curStep,
-      Ordering scanOrder) {
+      Ordering scanOrder,
+      List<AggregationDescriptor> aggregationDescriptorList) {
     if (aggregationExpressions == null) {
       return this;
     }
 
-    List<AggregationDescriptor> aggregationDescriptorList =
-        constructAggregationDescriptorList(aggregationExpressions, curStep);
-    updateTypeProvider(aggregationExpressions);
-    if (curStep.isOutputPartial()) {
-      aggregationDescriptorList.forEach(
-          aggregationDescriptor ->
-              updateTypeProviderByPartialAggregation(
-                  aggregationDescriptor, context.getTypeProvider()));
-    }
     this.root =
         new RawDataAggregationNode(
             context.getQueryId().genPlanNodeId(),
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/AggregationDescriptor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/AggregationDescriptor.java
index d266de50aaad..c7758007d36e 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/AggregationDescriptor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/AggregationDescriptor.java
@@ -265,7 +265,7 @@ public List<String> getInputExpressionsAsStringList() {
 
   protected String getInputString(List<Expression> expressions) {
     StringBuilder builder = new StringBuilder();
-    if (!(expressions.size() == 0)) {
+    if (!(expressions.isEmpty())) {
       builder.append(expressions.get(0).getExpressionString());
       for (int i = 1; i < expressions.size(); ++i) {
         builder.append(", ").append(expressions.get(i).getExpressionString());

From a63cb4e303bfa215e2ac04633a1a2439657eaba3 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Sat, 11 May 2024 21:20:19 +0800
Subject: [PATCH 03/28] fix normal query error

---
 .../db/queryengine/plan/analyze/Analysis.java   | 17 ++++++++---------
 .../plan/analyze/ExpressionTypeAnalyzer.java    |  2 +-
 .../analyze/TemplatedAggregationAnalyze.java    |  2 ++
 .../plan/analyze/TemplatedAnalyze.java          |  2 +-
 .../plan/optimization/AggregationPushDown.java  |  8 ++++----
 .../plan/optimization/PredicatePushDown.java    |  2 +-
 .../plan/planner/LogicalPlanVisitor.java        |  2 +-
 7 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java
index 3a58adc130ed..9cfd952fc317 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java
@@ -292,7 +292,7 @@ aggregation results last_value(temperature) and last_value(status), whereas buck
   private Template deviceTemplate;
   // when deviceTemplate is not empty and all expressions in this query are templated measurements,
   // i.e. no aggregation and arithmetic expression
-  private boolean onlyQueryTemplateMeasurements = true;
+  private boolean noWhereAndAggregation = true;
   // if it is wildcard query in templated align by device query
   private boolean templateWildCardQuery;
   // all queried measurementList and schemaList in deviceTemplate.
@@ -408,9 +408,8 @@ public TSDataType getType(Expression expression) {
       return null;
     }
 
-    if (isAllDevicesInOneTemplate()
-        && isOnlyQueryTemplateMeasurements()
-        && expression instanceof TimeSeriesOperand) {
+    if (allDevicesInOneTemplate()
+        && (noWhereAndAggregation() || expression instanceof TimeSeriesOperand)) {
       TimeSeriesOperand seriesOperand = (TimeSeriesOperand) expression;
       return deviceTemplate.getSchemaMap().get(seriesOperand.getPath().getMeasurement()).getType();
     }
@@ -893,7 +892,7 @@ public List<PartialPath> getDeviceList() {
   // All Queries Devices Set In One Template
   /////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public boolean isAllDevicesInOneTemplate() {
+  public boolean allDevicesInOneTemplate() {
     return this.deviceTemplate != null;
   }
 
@@ -905,12 +904,12 @@ public void setDeviceTemplate(Template template) {
     this.deviceTemplate = template;
   }
 
-  public boolean isOnlyQueryTemplateMeasurements() {
-    return onlyQueryTemplateMeasurements;
+  public boolean noWhereAndAggregation() {
+    return noWhereAndAggregation;
   }
 
-  public void setOnlyQueryTemplateMeasurements(boolean onlyQueryTemplateMeasurements) {
-    this.onlyQueryTemplateMeasurements = onlyQueryTemplateMeasurements;
+  public void setNoWhereAndAggregation(boolean value) {
+    this.noWhereAndAggregation = value;
   }
 
   public List<String> getMeasurementList() {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
index 1cd7fbcf8367..4abc81a04aad 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
@@ -68,7 +68,7 @@ public static TSDataType analyzeExpression(Analysis analysis, Expression express
       ExpressionTypeAnalyzer analyzer = new ExpressionTypeAnalyzer();
 
       Map<String, IMeasurementSchema> context =
-          analysis.isAllDevicesInOneTemplate() ? analysis.getDeviceTemplate().getSchemaMap() : null;
+          analysis.allDevicesInOneTemplate() ? analysis.getDeviceTemplate().getSchemaMap() : null;
       analyzer.analyze(expression, context);
 
       addExpressionTypes(analysis, analyzer);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index 60211412341d..e9491eb0904f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -59,6 +59,8 @@ static boolean analyzeAggregation(
       MPPQueryContext context,
       Template template) {
 
+    analysis.setNoWhereAndAggregation(false);
+
     List<PartialPath> deviceList = analyzeFrom(queryStatement, schemaTree);
 
     if (canPushDownLimitOffsetInGroupByTimeForDevice(queryStatement)) {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
index 1814a923d241..a9a168e8cf27 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
@@ -253,7 +253,7 @@ static void analyzeDeviceToWhere(Analysis analysis, QueryStatement queryStatemen
       return;
     }
 
-    analysis.setOnlyQueryTemplateMeasurements(false);
+    analysis.setNoWhereAndAggregation(false);
     Expression wherePredicate =
         new TemplatedConcatRemoveUnExistentMeasurementVisitor()
             .process(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index ec1d2fdb09ad..ebe3b5cccdd0 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -94,7 +94,7 @@ public PlanNode optimize(PlanNode plan, Analysis analysis, MPPQueryContext conte
   private boolean cannotUseStatistics(QueryStatement queryStatement, Analysis analysis) {
     boolean isAlignByDevice = queryStatement.isAlignByDevice();
     if (isAlignByDevice) {
-      if (analysis.isAllDevicesInOneTemplate()) {
+      if (analysis.allDevicesInOneTemplate()) {
         // TODO agg+template situation, how about the SourceTransformExpressions
         return cannotUseStatistics(
             analysis.getAggregationExpressions(), analysis.getAggregationExpressions());
@@ -180,7 +180,7 @@ public PlanNode visitDeviceView(DeviceViewNode node, RewriterContext context) {
       List<PlanNode> rewrittenChildren = new ArrayList<>();
       for (int i = 0; i < node.getDevices().size(); i++) {
         context.setCurDevice(node.getDevices().get(i));
-        if (context.analysis.isAllDevicesInOneTemplate()) {
+        if (context.analysis.allDevicesInOneTemplate()) {
           context.setCurDevicePath(context.analysis.getDeviceList().get(i));
         }
 
@@ -270,7 +270,7 @@ public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterCon
         }
 
         List<PlanNode> sourceNodeList;
-        if (context.analysis.isAllDevicesInOneTemplate()) {
+        if (context.analysis.allDevicesInOneTemplate()) {
           sourceNodeList =
               constructSourceNodeFromTemplateAggregationDescriptors(
                   sourceToAscendingAggregationsMap,
@@ -571,7 +571,7 @@ public void setCurDevicePath(PartialPath devicePath) {
 
     public Set<Expression> getAggregationExpressions() {
       if (isAlignByDevice) {
-        if (analysis.isAllDevicesInOneTemplate()) {
+        if (analysis.allDevicesInOneTemplate()) {
           return analysis.getAggregationExpressions();
         } else {
           return analysis.getDeviceToAggregationExpressions().get(curDevice);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java
index 2207b94f6b89..7c8c93c18147 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java
@@ -402,7 +402,7 @@ private static class RewriterContext {
     private RewriterContext(Analysis analysis, MPPQueryContext context, boolean isAlignByDevice) {
       this.queryId = context.getQueryId();
       this.isAlignByDevice = isAlignByDevice;
-      this.isBuildPlanUseTemplate = analysis.isAllDevicesInOneTemplate();
+      this.isBuildPlanUseTemplate = analysis.allDevicesInOneTemplate();
       this.templatedInfo = context.getTypeProvider().getTemplatedInfo();
       this.filterNodeFromWhereChecker = analysis::fromWhere;
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java
index 664924b2004e..8137090e5dc7 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java
@@ -134,7 +134,7 @@ public PlanNode visitExplainAnalyze(
 
   @Override
   public PlanNode visitQuery(QueryStatement queryStatement, MPPQueryContext context) {
-    if (analysis.isAllDevicesInOneTemplate()) {
+    if (analysis.allDevicesInOneTemplate()) {
       return new TemplatedLogicalPlan(analysis, queryStatement, context).visitQuery();
     }
 

From b732c751c68ad715d8d40ddeb62429893bed0c43 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Sat, 11 May 2024 21:45:55 +0800
Subject: [PATCH 04/28] add distributed serialize

---
 .../plan/analyze/TemplatedInfo.java           | 28 +++++++++++++++
 .../plan/planner/TemplatedLogicalPlan.java    |  2 ++
 .../plan/planner/plan/node/PlanNodeType.java  |  2 ++
 .../AlignedSeriesAggregationScanNode.java     | 36 +++++++++++++++++++
 4 files changed, 68 insertions(+)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
index f042c36a07d2..2bb10715ffdc 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
@@ -104,6 +104,7 @@ public TemplatedInfo(
       Map<String, IMeasurementSchema> schemaMap,
       Map<String, List<InputLocation>> layoutMap,
       Expression pushDownPredicate,
+      List<AggregationDescriptor> aggregationDescriptorList,
       GroupByTimeParameter groupByTimeParameter,
       boolean outputEndTime) {
     this.measurementList = measurementList;
@@ -123,6 +124,7 @@ public TemplatedInfo(
     }
     this.pushDownPredicate = pushDownPredicate;
 
+    this.aggregationDescriptorList = aggregationDescriptorList;
     this.groupByTimeParameter = groupByTimeParameter;
     this.outputEndTime = outputEndTime;
   }
@@ -259,6 +261,13 @@ public void serialize(ByteBuffer byteBuffer) {
     } else {
       ReadWriteIOUtils.write((byte) 0, byteBuffer);
     }
+
+    if (aggregationDescriptorList != null) {
+      ReadWriteIOUtils.write(aggregationDescriptorList.size(), byteBuffer);
+      aggregationDescriptorList.forEach(d -> d.serialize(byteBuffer));
+    } else {
+      ReadWriteIOUtils.write((byte) 0, byteBuffer);
+    }
   }
 
   public void serialize(DataOutputStream stream) throws IOException {
@@ -302,6 +311,15 @@ public void serialize(DataOutputStream stream) throws IOException {
     } else {
       ReadWriteIOUtils.write((byte) 0, stream);
     }
+
+    if (aggregationDescriptorList != null) {
+      ReadWriteIOUtils.write(aggregationDescriptorList.size(), stream);
+      for (AggregationDescriptor descriptor : aggregationDescriptorList) {
+        descriptor.serialize(stream);
+      }
+    } else {
+      ReadWriteIOUtils.write((byte) 0, stream);
+    }
   }
 
   public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
@@ -367,6 +385,15 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
       pushDownPredicate = Expression.deserialize(byteBuffer);
     }
 
+    List<AggregationDescriptor> aggregationDescriptorList = null;
+    listSize = ReadWriteIOUtils.readInt(byteBuffer);
+    if (listSize > 0) {
+      aggregationDescriptorList = new ArrayList<>(listSize);
+      while (listSize-- > 0) {
+        aggregationDescriptorList.add(AggregationDescriptor.deserialize(byteBuffer));
+      }
+    }
+
     // TODO add groupByTimeParameter, outputEndTime serialization and deserialization
 
     return new TemplatedInfo(
@@ -384,6 +411,7 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
         currentSchemaMap,
         layoutMap,
         pushDownPredicate,
+        aggregationDescriptorList,
         null,
         false);
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
index 6117e8795d96..8242c3385449 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
@@ -155,6 +155,7 @@ private void initAggQueryCommonVariables() {
                 analysis.getDeviceTemplate().getSchemaMap(),
                 filterLayoutMap,
                 null,
+                null,
                 analysis.getGroupByTimeParameter(),
                 queryStatement.isOutputEndTime()));
   }
@@ -212,6 +213,7 @@ private void initNonAggQueryCommonVariables() {
                 analysis.getDeviceTemplate().getSchemaMap(),
                 filterLayoutMap,
                 null,
+                null,
                 analysis.getGroupByTimeParameter(),
                 queryStatement.isOutputEndTime()));
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java
index 41d912e145c5..33acaba67fe0 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java
@@ -462,6 +462,8 @@ public static PlanNode deserializeWithTemplate(ByteBuffer buffer, TypeProvider t
         return FilterNode.deserializeUseTemplate(buffer, typeProvider);
       case 33:
         return AlignedSeriesScanNode.deserializeUseTemplate(buffer, typeProvider);
+      case 34:
+        return AlignedSeriesAggregationScanNode.deserializeUseTemplate(buffer, typeProvider);
       case 65:
         return SingleDeviceViewNode.deserializeUseTemplate(buffer, typeProvider);
       case 32:
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
index 06392041ed93..42e076d0e37b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
@@ -23,6 +23,7 @@
 import org.apache.iotdb.commons.path.AlignedPath;
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.commons.path.PathDeserializeUtil;
+import org.apache.iotdb.db.queryengine.plan.analyze.TypeProvider;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeId;
@@ -255,6 +256,41 @@ public static AlignedSeriesAggregationScanNode deserialize(ByteBuffer byteBuffer
         null);
   }
 
+  @Override
+  public void serializeUseTemplate(DataOutputStream stream, TypeProvider typeProvider)
+      throws IOException {
+    PlanNodeType.ALIGNED_SERIES_AGGREGATE_SCAN.serialize(stream);
+    id.serialize(stream);
+    ReadWriteIOUtils.write(alignedPath.getNodes().length, stream);
+    for (String node : alignedPath.getNodes()) {
+      ReadWriteIOUtils.write(node, stream);
+    }
+  }
+
+  public static AlignedSeriesAggregationScanNode deserializeUseTemplate(
+      ByteBuffer byteBuffer, TypeProvider typeProvider) {
+    PlanNodeId planNodeId = PlanNodeId.deserialize(byteBuffer);
+
+    int nodeSize = ReadWriteIOUtils.readInt(byteBuffer);
+    String[] nodes = new String[nodeSize];
+    for (int i = 0; i < nodeSize; i++) {
+      nodes[i] = ReadWriteIOUtils.readString(byteBuffer);
+    }
+    AlignedPath alignedPath = new AlignedPath(new PartialPath(nodes));
+    alignedPath.setMeasurementList(typeProvider.getTemplatedInfo().getMeasurementList());
+    alignedPath.addSchemas(typeProvider.getTemplatedInfo().getSchemaList());
+
+    return new AlignedSeriesAggregationScanNode(
+        planNodeId,
+        alignedPath,
+        typeProvider.getTemplatedInfo().aggregationDescriptorList,
+        typeProvider.getTemplatedInfo().getScanOrder(),
+        typeProvider.getTemplatedInfo().outputEndTime,
+        typeProvider.getTemplatedInfo().getPushDownPredicate(),
+        typeProvider.getTemplatedInfo().groupByTimeParameter,
+        null);
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {

From 8699ede457913667496ca5ed4f40e9abd243f832 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Mon, 13 May 2024 08:35:43 +0800
Subject: [PATCH 05/28] fix sourcenode

---
 .../iotdb/db/queryengine/plan/planner/plan/PlanFragment.java  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
index 4276cba4290d..2861a00d46bd 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
@@ -27,7 +27,7 @@
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.IPartitionRelatedNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeType;
-import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.AlignedSeriesScanNode;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.SeriesSourceNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.VirtualSourceNode;
 
 import org.apache.tsfile.utils.ReadWriteIOUtils;
@@ -183,7 +183,7 @@ public static PlanNode deserializeHelper(ByteBuffer byteBuffer, TypeProvider typ
     PlanNode root;
     if (typeProvider != null && typeProvider.getTemplatedInfo() != null) {
       root = PlanNodeType.deserializeWithTemplate(byteBuffer, typeProvider);
-      if (root instanceof AlignedSeriesScanNode) {
+      if (root instanceof SeriesSourceNode) {
         return root;
       }
     } else {

From e7985faef09c972a671c4a68a2041b0c7e1d026b Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Mon, 13 May 2024 14:14:03 +0800
Subject: [PATCH 06/28] fix template serizlize error; fix filter can not push
 down bug

---
 .../plan/analyze/TemplatedInfo.java           | 26 +++++++++----------
 .../plan/planner/OperatorTreeGenerator.java   | 15 ++++++++---
 .../planner/TemplatedLogicalPlanBuilder.java  |  5 +++-
 .../plan/planner/plan/PlanFragment.java       |  6 +++--
 .../planner/plan/node/PlanGraphPrinter.java   |  2 +-
 .../node/process/SingleDeviceViewNode.java    |  2 +-
 6 files changed, 33 insertions(+), 23 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
index 2bb10715ffdc..a0e5dc09d4f9 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
@@ -41,7 +41,6 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 import static org.apache.iotdb.db.queryengine.plan.expression.leaf.TimestampOperand.TIMESTAMP_EXPRESSION_STRING;
 
@@ -61,7 +60,7 @@ public class TemplatedInfo {
   private final boolean queryAllSensors;
 
   // variables used in DeviceViewOperator
-  private final List<String> selectMeasurements;
+  private final List<String> deviceViewOutputNames;
   private final List<Integer> deviceToMeasurementIndexes;
 
   // variables related to LIMIT/OFFSET push down
@@ -84,9 +83,8 @@ public class TemplatedInfo {
   // variables related to aggregation
   public List<AggregationDescriptor> aggregationDescriptorList;
   public GroupByTimeParameter groupByTimeParameter;
-  public boolean outputEndTime = false;
+  public boolean outputEndTime;
 
-  private Set<Expression> aggSelectExpressions;
   private Expression havingExpression;
 
   public TemplatedInfo(
@@ -95,7 +93,7 @@ public TemplatedInfo(
       List<TSDataType> dataTypes,
       Ordering scanOrder,
       boolean queryAllSensors,
-      List<String> selectMeasurements,
+      List<String> deviceViewOutputNames,
       List<Integer> deviceToMeasurementIndexes,
       long offsetValue,
       long limitValue,
@@ -112,7 +110,7 @@ public TemplatedInfo(
     this.dataTypes = dataTypes;
     this.scanOrder = scanOrder;
     this.queryAllSensors = queryAllSensors;
-    this.selectMeasurements = selectMeasurements;
+    this.deviceViewOutputNames = deviceViewOutputNames;
     this.deviceToMeasurementIndexes = deviceToMeasurementIndexes;
     this.offsetValue = offsetValue;
     this.limitValue = limitValue;
@@ -149,8 +147,8 @@ public boolean isQueryAllSensors() {
     return this.queryAllSensors;
   }
 
-  public List<String> getSelectMeasurements() {
-    return this.selectMeasurements;
+  public List<String> getDeviceViewOutputNames() {
+    return this.deviceViewOutputNames;
   }
 
   public long getOffsetValue() {
@@ -234,8 +232,8 @@ public void serialize(ByteBuffer byteBuffer) {
     ReadWriteIOUtils.write(scanOrder.ordinal(), byteBuffer);
     ReadWriteIOUtils.write(queryAllSensors, byteBuffer);
 
-    ReadWriteIOUtils.write(selectMeasurements.size(), byteBuffer);
-    for (String selectMeasurement : selectMeasurements) {
+    ReadWriteIOUtils.write(deviceViewOutputNames.size(), byteBuffer);
+    for (String selectMeasurement : deviceViewOutputNames) {
       ReadWriteIOUtils.write(selectMeasurement, byteBuffer);
     }
 
@@ -266,7 +264,7 @@ public void serialize(ByteBuffer byteBuffer) {
       ReadWriteIOUtils.write(aggregationDescriptorList.size(), byteBuffer);
       aggregationDescriptorList.forEach(d -> d.serialize(byteBuffer));
     } else {
-      ReadWriteIOUtils.write((byte) 0, byteBuffer);
+      ReadWriteIOUtils.write(0, byteBuffer);
     }
   }
 
@@ -284,8 +282,8 @@ public void serialize(DataOutputStream stream) throws IOException {
     ReadWriteIOUtils.write(scanOrder.ordinal(), stream);
     ReadWriteIOUtils.write(queryAllSensors, stream);
 
-    ReadWriteIOUtils.write(selectMeasurements.size(), stream);
-    for (String selectMeasurement : selectMeasurements) {
+    ReadWriteIOUtils.write(deviceViewOutputNames.size(), stream);
+    for (String selectMeasurement : deviceViewOutputNames) {
       ReadWriteIOUtils.write(selectMeasurement, stream);
     }
 
@@ -318,7 +316,7 @@ public void serialize(DataOutputStream stream) throws IOException {
         descriptor.serialize(stream);
       }
     } else {
-      ReadWriteIOUtils.write((byte) 0, stream);
+      ReadWriteIOUtils.write(0, stream);
     }
   }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
index 1783480abb89..c156757729f8 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
@@ -494,10 +494,17 @@ public Operator visitProject(ProjectNode node, LocalExecutionPlanContext context
     List<String> inputColumnNames;
     List<String> outputColumnNames = node.getOutputColumnNames();
     if (outputColumnNames == null) {
-      outputColumnNames = context.getTypeProvider().getTemplatedInfo().getSelectMeasurements();
-      // skip device column
-      outputColumnNames = outputColumnNames.subList(1, outputColumnNames.size());
-      inputColumnNames = context.getTypeProvider().getTemplatedInfo().getMeasurementList();
+      if (context.getTypeProvider().getTemplatedInfo().aggregationDescriptorList != null) {
+        // outputColumnNames is aggregation expression
+        outputColumnNames = context.getTypeProvider().getTemplatedInfo().getDeviceViewOutputNames();
+        outputColumnNames = outputColumnNames.subList(1, outputColumnNames.size());
+        inputColumnNames = context.getTypeProvider().getTemplatedInfo().getMeasurementList();
+      } else {
+        outputColumnNames = context.getTypeProvider().getTemplatedInfo().getDeviceViewOutputNames();
+        // skip device column
+        outputColumnNames = outputColumnNames.subList(1, outputColumnNames.size());
+        inputColumnNames = context.getTypeProvider().getTemplatedInfo().getMeasurementList();
+      }
     } else {
       inputColumnNames = node.getChild().getOutputColumnNames();
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
index 6ef95f0e1196..1cae21e89219 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
@@ -121,7 +121,7 @@ public TemplatedLogicalPlanBuilder planFilter(
       return this;
     }
 
-    this.root =
+    FilterNode filterNode =
         new FilterNode(
             context.getQueryId().genPlanNodeId(),
             this.getRoot(),
@@ -129,6 +129,9 @@ public TemplatedLogicalPlanBuilder planFilter(
             filterExpression,
             isGroupByTime,
             scanOrder);
+    analysis.setFromWhere(filterNode);
+
+    this.root = filterNode;
 
     return this;
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
index 2861a00d46bd..e9e18ef9548c 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
@@ -27,7 +27,8 @@
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.IPartitionRelatedNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeType;
-import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.SeriesSourceNode;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.AlignedSeriesAggregationScanNode;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.AlignedSeriesScanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.VirtualSourceNode;
 
 import org.apache.tsfile.utils.ReadWriteIOUtils;
@@ -183,7 +184,8 @@ public static PlanNode deserializeHelper(ByteBuffer byteBuffer, TypeProvider typ
     PlanNode root;
     if (typeProvider != null && typeProvider.getTemplatedInfo() != null) {
       root = PlanNodeType.deserializeWithTemplate(byteBuffer, typeProvider);
-      if (root instanceof SeriesSourceNode) {
+      if (root instanceof AlignedSeriesScanNode
+          || root instanceof AlignedSeriesAggregationScanNode) {
         return root;
       }
     } else {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanGraphPrinter.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanGraphPrinter.java
index 09fe6c92960b..730edb747b78 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanGraphPrinter.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanGraphPrinter.java
@@ -452,7 +452,7 @@ public List<String> visitProject(ProjectNode node, GraphContext context) {
     List<String> outputColumns = node.getOutputColumnNames();
     if (outputColumns == null) {
       checkArgument(context.getTemplatedInfo() != null);
-      outputColumns = context.getTemplatedInfo().getSelectMeasurements();
+      outputColumns = context.getTemplatedInfo().getDeviceViewOutputNames();
       // skip device column
       outputColumns = outputColumns.subList(1, outputColumns.size());
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/SingleDeviceViewNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/SingleDeviceViewNode.java
index c1b3898ed286..263223c5d5cd 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/SingleDeviceViewNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/SingleDeviceViewNode.java
@@ -190,7 +190,7 @@ public static SingleDeviceViewNode deserializeUseTemplate(
     return new SingleDeviceViewNode(
         planNodeId,
         cacheOutputColumnNames,
-        typeProvider.getTemplatedInfo().getSelectMeasurements(),
+        typeProvider.getTemplatedInfo().getDeviceViewOutputNames(),
         device,
         typeProvider.getTemplatedInfo().getDeviceToMeasurementIndexes());
   }

From 15925076f75872d53d295733eaef7629b993fc4f Mon Sep 17 00:00:00 2001
From: Minghui Liu <liuminghui233@foxmail.com>
Date: Tue, 14 May 2024 00:33:23 +0800
Subject: [PATCH 07/28] process ProjectNode

---
 .../queryengine/plan/optimization/AggregationPushDown.java   | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index 344572be2b36..a9a7a111919f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -225,6 +225,11 @@ public PlanNode visitGroupByTag(GroupByTagNode node, RewriterContext context) {
     @Override
     public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterContext context) {
       PlanNode child = node.getChild();
+      if (child instanceof ProjectNode) {
+        // remove ProjectNode
+        node.setChild(((ProjectNode) child).getChild());
+        return visitRawDataAggregation(node, context);
+      }
       if (child instanceof FullOuterTimeJoinNode || child instanceof SeriesScanSourceNode) {
         boolean isSingleSource = child instanceof SeriesScanSourceNode;
         boolean needCheckAscending = node.getGroupByTimeParameter() == null;

From 8ba69593e3629b7f0d27d61f222f06c82720c5df Mon Sep 17 00:00:00 2001
From: Minghui Liu <liuminghui233@foxmail.com>
Date: Tue, 14 May 2024 00:33:31 +0800
Subject: [PATCH 08/28] fix UT

---
 .../AggregationAlignByDeviceTest.java         |  44 ---
 .../distribution/AlignedByDeviceTest.java     | 328 ++----------------
 2 files changed, 27 insertions(+), 345 deletions(-)

diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/AggregationAlignByDeviceTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/AggregationAlignByDeviceTest.java
index 1753102d8128..f6bb0deea1cf 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/AggregationAlignByDeviceTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/AggregationAlignByDeviceTest.java
@@ -209,17 +209,6 @@ public void orderByDeviceTest2() {
         firstFiTopNode.getChildren().get(0).getChildren().get(0) instanceof RawDataAggregationNode);
     assertTrue(
         firstFiTopNode.getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        firstFiTopNode
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
             instanceof LeftOuterTimeJoinNode);
 
     secondFiRoot = plan.getInstances().get(1).getFragment().getPlanNodeTree();
@@ -229,17 +218,6 @@ public void orderByDeviceTest2() {
         secondFiRoot.getChildren().get(0).getChildren().get(0) instanceof RawDataAggregationNode);
     assertTrue(
         secondFiRoot.getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        secondFiRoot
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
             instanceof LeftOuterTimeJoinNode);
 
     // two aggregation measurement, two devices, with filter
@@ -260,17 +238,6 @@ public void orderByDeviceTest2() {
         firstFiTopNode.getChildren().get(0).getChildren().get(0) instanceof RawDataAggregationNode);
     assertTrue(
         firstFiTopNode.getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        firstFiTopNode
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
             instanceof LeftOuterTimeJoinNode);
 
     secondFiRoot = plan.getInstances().get(1).getFragment().getPlanNodeTree();
@@ -280,17 +247,6 @@ public void orderByDeviceTest2() {
         secondFiRoot.getChildren().get(0).getChildren().get(0) instanceof RawDataAggregationNode);
     assertTrue(
         secondFiRoot.getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        secondFiRoot
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
             instanceof LeftOuterTimeJoinNode);
   }
 
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/AlignedByDeviceTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/AlignedByDeviceTest.java
index 80a024ce7f6d..9788584e2179 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/AlignedByDeviceTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/AlignedByDeviceTest.java
@@ -137,14 +137,16 @@ public void testAggregation2Device2RegionWithValueFilter() {
     assertTrue(f1Root.getChildren().get(0).getChildren().get(0) instanceof DeviceViewNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof RawDataAggregationNode);
+            instanceof SeriesAggregationScanNode);
     assertTrue(
-        f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
+        f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(1)
+            instanceof SeriesAggregationScanNode);
     assertTrue(f2Root instanceof IdentitySinkNode);
     assertTrue(f2Root.getChildren().get(0) instanceof DeviceViewNode);
-    assertTrue(f2Root.getChildren().get(0).getChildren().get(0) instanceof RawDataAggregationNode);
-    assertTrue(f2Root.getChildren().get(0).getChildren().get(1) instanceof RawDataAggregationNode);
+    assertTrue(
+        f2Root.getChildren().get(0).getChildren().get(0) instanceof SeriesAggregationScanNode);
+    assertTrue(
+        f2Root.getChildren().get(0).getChildren().get(1) instanceof SeriesAggregationScanNode);
 
     // test of MULTI_SERIES
     sql =
@@ -163,17 +165,7 @@ public void testAggregation2Device2RegionWithValueFilter() {
         f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0)
             instanceof RawDataAggregationNode);
     assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
+        f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(0)
             instanceof LeftOuterTimeJoinNode);
     assertTrue(
         f1Root
@@ -187,8 +179,6 @@ public void testAggregation2Device2RegionWithValueFilter() {
                 .get(0)
                 .getChildren()
                 .get(0)
-                .getChildren()
-                .get(0)
             instanceof SeriesSourceNode);
     assertTrue(f1Root.getChildren().get(0).getChildren().get(1) instanceof ExchangeNode);
     assertTrue(
@@ -371,106 +361,26 @@ public void testAggregation2Device2RegionWithValueFilterOrderByTime() {
     assertTrue(f1Root.getChildren().get(0).getChildren().get(0) instanceof SingleDeviceViewNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof RawDataAggregationNode);
+            instanceof AggregationNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-            instanceof FullOuterTimeJoinNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-            instanceof SeriesScanNode);
+            instanceof SeriesAggregationScanNode);
     assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
+        f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(1)
             instanceof ExchangeNode);
     assertTrue(f1Root.getChildren().get(0).getChildren().get(1) instanceof SingleDeviceViewNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(1).getChildren().get(0)
-            instanceof RawDataAggregationNode);
+            instanceof AggregationNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(1).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-            instanceof FullOuterTimeJoinNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-            instanceof SeriesScanNode);
+            instanceof SeriesAggregationScanNode);
     assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
+        f1Root.getChildren().get(0).getChildren().get(1).getChildren().get(0).getChildren().get(1)
             instanceof ExchangeNode);
     assertTrue(f2Root instanceof ShuffleSinkNode);
-    assertTrue(f2Root.getChildren().get(0) instanceof SeriesSourceNode);
-    assertTrue(f2Root.getChildren().get(1) instanceof SeriesSourceNode);
+    assertTrue(f2Root.getChildren().get(0) instanceof SeriesAggregationScanNode);
+    assertTrue(f2Root.getChildren().get(1) instanceof SeriesAggregationScanNode);
 
     // test of MULTI_SERIES
     sql =
@@ -490,19 +400,6 @@ public void testAggregation2Device2RegionWithValueFilterOrderByTime() {
             instanceof RawDataAggregationNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
             instanceof LeftOuterTimeJoinNode);
     assertTrue(
         f1Root
@@ -516,8 +413,6 @@ public void testAggregation2Device2RegionWithValueFilterOrderByTime() {
                 .get(0)
                 .getChildren()
                 .get(0)
-                .getChildren()
-                .get(0)
             instanceof FullOuterTimeJoinNode);
     assertTrue(
         f1Root
@@ -533,8 +428,6 @@ public void testAggregation2Device2RegionWithValueFilterOrderByTime() {
                 .get(0)
                 .getChildren()
                 .get(0)
-                .getChildren()
-                .get(0)
             instanceof SeriesSourceNode);
     assertTrue(
         f1Root
@@ -549,8 +442,6 @@ public void testAggregation2Device2RegionWithValueFilterOrderByTime() {
                 .getChildren()
                 .get(0)
                 .getChildren()
-                .get(0)
-                .getChildren()
                 .get(1)
             instanceof ExchangeNode);
     assertTrue(f1Root.getChildren().get(0).getChildren().get(1) instanceof SingleDeviceViewNode);
@@ -559,19 +450,6 @@ public void testAggregation2Device2RegionWithValueFilterOrderByTime() {
             instanceof RawDataAggregationNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(1).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
             instanceof LeftOuterTimeJoinNode);
     assertTrue(
         f1Root
@@ -585,8 +463,6 @@ public void testAggregation2Device2RegionWithValueFilterOrderByTime() {
                 .get(0)
                 .getChildren()
                 .get(0)
-                .getChildren()
-                .get(0)
             instanceof FullOuterTimeJoinNode);
     assertTrue(
         f1Root
@@ -602,8 +478,6 @@ public void testAggregation2Device2RegionWithValueFilterOrderByTime() {
                 .get(0)
                 .getChildren()
                 .get(0)
-                .getChildren()
-                .get(0)
             instanceof SeriesSourceNode);
     assertTrue(
         f1Root
@@ -618,8 +492,6 @@ public void testAggregation2Device2RegionWithValueFilterOrderByTime() {
                 .getChildren()
                 .get(0)
                 .getChildren()
-                .get(0)
-                .getChildren()
                 .get(1)
             instanceof ExchangeNode);
     assertTrue(f2Root instanceof ShuffleSinkNode);
@@ -739,23 +611,7 @@ public void testAggregation2Device3RegionWithValueFilter() {
     assertTrue(f1Root.getChildren().get(0).getChildren().get(0) instanceof DeviceViewNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof RawDataAggregationNode);
-    assertTrue(
-        f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-            instanceof SeriesScanNode);
+            instanceof SeriesAggregationScanNode);
     assertTrue(f2Root instanceof IdentitySinkNode);
     assertTrue(f2Root.getChildren().get(0) instanceof DeviceViewNode);
     assertTrue(f3Root instanceof IdentitySinkNode);
@@ -778,8 +634,8 @@ public void testAggregation2Device3RegionWithValueFilter() {
         f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0)
             instanceof RawDataAggregationNode);
     assertTrue(
-        f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
+        f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(1)
+            instanceof RawDataAggregationNode);
     assertTrue(f2Root instanceof IdentitySinkNode);
     assertTrue(f2Root.getChildren().get(0) instanceof DeviceViewNode);
     assertTrue(f3Root instanceof IdentitySinkNode);
@@ -961,107 +817,27 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
     assertTrue(f1Root.getChildren().get(0).getChildren().get(0) instanceof SingleDeviceViewNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof RawDataAggregationNode);
+            instanceof AggregationNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-            instanceof FullOuterTimeJoinNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-            instanceof SeriesScanNode);
+            instanceof SeriesAggregationScanNode);
     assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
+        f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(1)
             instanceof ExchangeNode);
     assertTrue(f1Root.getChildren().get(0).getChildren().get(1) instanceof SingleDeviceViewNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(1).getChildren().get(0)
-            instanceof RawDataAggregationNode);
+            instanceof AggregationNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(1).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-            instanceof FullOuterTimeJoinNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-            instanceof SeriesScanNode);
+            instanceof SeriesAggregationScanNode);
     assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
+        f1Root.getChildren().get(0).getChildren().get(1).getChildren().get(0).getChildren().get(1)
             instanceof ExchangeNode);
     assertTrue(f2Root instanceof ShuffleSinkNode);
-    assertTrue(f2Root.getChildren().get(0) instanceof SeriesScanNode);
+    assertTrue(f2Root.getChildren().get(0) instanceof SeriesAggregationScanNode);
     assertTrue(f3Root instanceof ShuffleSinkNode);
-    assertTrue(f3Root.getChildren().get(0) instanceof SeriesScanNode);
+    assertTrue(f3Root.getChildren().get(0) instanceof SeriesAggregationScanNode);
 
     // test of MULTI_SERIES
     sql =
@@ -1082,19 +858,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
             instanceof RawDataAggregationNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
             instanceof LeftOuterTimeJoinNode);
     assertTrue(
         f1Root
@@ -1108,8 +871,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .get(0)
                 .getChildren()
                 .get(0)
-                .getChildren()
-                .get(0)
             instanceof FullOuterTimeJoinNode);
     assertTrue(
         f1Root
@@ -1125,8 +886,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .get(0)
                 .getChildren()
                 .get(0)
-                .getChildren()
-                .get(0)
             instanceof SeriesSourceNode);
     assertTrue(
         f1Root
@@ -1141,8 +900,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .getChildren()
                 .get(0)
                 .getChildren()
-                .get(0)
-                .getChildren()
                 .get(1)
             instanceof ExchangeNode);
     assertTrue(
@@ -1156,8 +913,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .getChildren()
                 .get(0)
                 .getChildren()
-                .get(0)
-                .getChildren()
                 .get(1)
             instanceof FullOuterTimeJoinNode);
     assertTrue(
@@ -1171,8 +926,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .getChildren()
                 .get(0)
                 .getChildren()
-                .get(0)
-                .getChildren()
                 .get(1)
                 .getChildren()
                 .get(0)
@@ -1188,8 +941,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .getChildren()
                 .get(0)
                 .getChildren()
-                .get(0)
-                .getChildren()
                 .get(1)
                 .getChildren()
                 .get(1)
@@ -1200,19 +951,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
             instanceof RawDataAggregationNode);
     assertTrue(
         f1Root.getChildren().get(0).getChildren().get(1).getChildren().get(0).getChildren().get(0)
-            instanceof ProjectNode);
-    assertTrue(
-        f1Root
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(1)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
-                .getChildren()
-                .get(0)
             instanceof LeftOuterTimeJoinNode);
     assertTrue(
         f1Root
@@ -1226,8 +964,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .get(0)
                 .getChildren()
                 .get(0)
-                .getChildren()
-                .get(0)
             instanceof FullOuterTimeJoinNode);
     assertTrue(
         f1Root
@@ -1243,8 +979,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .get(0)
                 .getChildren()
                 .get(0)
-                .getChildren()
-                .get(0)
             instanceof SeriesSourceNode);
     assertTrue(
         f1Root
@@ -1259,8 +993,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .getChildren()
                 .get(0)
                 .getChildren()
-                .get(0)
-                .getChildren()
                 .get(1)
             instanceof ExchangeNode);
     assertTrue(
@@ -1274,8 +1006,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .getChildren()
                 .get(0)
                 .getChildren()
-                .get(0)
-                .getChildren()
                 .get(1)
             instanceof FullOuterTimeJoinNode);
     assertTrue(
@@ -1289,8 +1019,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .getChildren()
                 .get(0)
                 .getChildren()
-                .get(0)
-                .getChildren()
                 .get(1)
                 .getChildren()
                 .get(0)
@@ -1306,8 +1034,6 @@ public void testAggregation2Device3RegionWithValueFilterOrderByTime() {
                 .getChildren()
                 .get(0)
                 .getChildren()
-                .get(0)
-                .getChildren()
                 .get(1)
                 .getChildren()
                 .get(1)

From d1924f304ac47d216056c24c1c31ff4c067547f9 Mon Sep 17 00:00:00 2001
From: Minghui Liu <liuminghui233@foxmail.com>
Date: Tue, 14 May 2024 00:56:33 +0800
Subject: [PATCH 09/28] add more UT

---
 .../optimization/AggregationPushDownTest.java | 69 +++++++++++++++++++
 .../plan/optimization/TestPlanBuilder.java    | 20 ++++++
 2 files changed, 89 insertions(+)

diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDownTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDownTest.java
index d43d17c13844..75655f68e648 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDownTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDownTest.java
@@ -34,6 +34,9 @@
 import java.util.Collections;
 import java.util.List;
 
+import static org.apache.iotdb.db.queryengine.plan.expression.ExpressionFactory.gt;
+import static org.apache.iotdb.db.queryengine.plan.expression.ExpressionFactory.intValue;
+import static org.apache.iotdb.db.queryengine.plan.expression.ExpressionFactory.timeSeries;
 import static org.apache.iotdb.db.queryengine.plan.optimization.OptimizationTestUtil.getAggregationDescriptor;
 import static org.apache.iotdb.db.queryengine.plan.optimization.OptimizationTestUtil.schemaMap;
 
@@ -246,6 +249,72 @@ public void testCannotPushDownTimeJoinAlignByTime() {
             .getRoot());
   }
 
+  @Test
+  public void testRemoveProject() {
+    GroupByTimeParameter groupByTimeParameter =
+        new GroupByTimeParameter(0, 100, new TimeDuration(0, 10), new TimeDuration(0, 10), true);
+    List<AggregationDescriptor> aggregationDescriptorList1 =
+        Collections.singletonList(
+            getAggregationDescriptor(AggregationStep.SINGLE, "root.sg.d2.a.s1"));
+
+    checkPushDown(
+        "select count(s1) from root.sg.d2.a where s2 > 1 group by ([0, 100), 10ms);",
+        new TestPlanBuilder()
+            .scanAligned(
+                "0",
+                schemaMap.get("root.sg.d2.a"),
+                ExpressionFactory.gt(
+                    ExpressionFactory.timeSeries(schemaMap.get("root.sg.d2.a.s2")),
+                    ExpressionFactory.intValue("1")))
+            .project("3", Collections.singletonList("root.sg.d2.a.s1"))
+            .rawDataAggregation("2", aggregationDescriptorList1, groupByTimeParameter, false)
+            .getRoot(),
+        new TestPlanBuilder()
+            .alignedAggregationScan(
+                "4",
+                schemaMap.get("aligned_root.sg.d2.a.s1"),
+                aggregationDescriptorList1,
+                groupByTimeParameter,
+                false,
+                ExpressionFactory.gt(
+                    ExpressionFactory.timeSeries(schemaMap.get("root.sg.d2.a.s2")),
+                    ExpressionFactory.intValue("1")))
+            .getRoot());
+
+    List<AggregationDescriptor> aggregationDescriptorList2 =
+        Collections.singletonList(
+            getAggregationDescriptor(AggregationStep.SINGLE, "root.sg.d1.s1"));
+    checkPushDown(
+        "select count(s1) from root.sg.d1 where time > 100 and s2 > 10 group by ([0, 100), 10ms);",
+        new TestPlanBuilder()
+            .leftOuterTimeJoin(
+                "5",
+                Ordering.ASC,
+                new TestPlanBuilder()
+                    .scan(
+                        "1",
+                        schemaMap.get("root.sg.d1.s2"),
+                        gt(timeSeries(schemaMap.get("root.sg.d1.s2")), intValue("10")))
+                    .getRoot(),
+                new TestPlanBuilder().scan("0", schemaMap.get("root.sg.d1.s1")).getRoot())
+            .project("6", Collections.singletonList("root.sg.d1.s1"))
+            .rawDataAggregation("4", aggregationDescriptorList2, groupByTimeParameter, false)
+            .getRoot(),
+        new TestPlanBuilder()
+            .leftOuterTimeJoin(
+                "5",
+                Ordering.ASC,
+                new TestPlanBuilder()
+                    .scan(
+                        "1",
+                        schemaMap.get("root.sg.d1.s2"),
+                        gt(timeSeries(schemaMap.get("root.sg.d1.s2")), intValue("10")))
+                    .getRoot(),
+                new TestPlanBuilder().scan("0", schemaMap.get("root.sg.d1.s1")).getRoot())
+            .rawDataAggregation("4", aggregationDescriptorList2, groupByTimeParameter, false)
+            .getRoot());
+  }
+
   private void checkPushDown(String sql, PlanNode rawPlan, PlanNode optPlan) {
     OptimizationTestUtil.checkPushDown(
         Collections.singletonList(new PredicatePushDown()),
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java
index b5f82ddc7a62..0ca53b7b84c3 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java
@@ -170,6 +170,26 @@ public TestPlanBuilder alignedAggregationScan(
     return this;
   }
 
+  public TestPlanBuilder alignedAggregationScan(
+      String id,
+      PartialPath path,
+      List<AggregationDescriptor> aggregationDescriptors,
+      GroupByTimeParameter groupByTimeParameter,
+      boolean outputEndTime,
+      Expression pushDownPredicate) {
+    AlignedSeriesAggregationScanNode aggregationScanNode =
+        new AlignedSeriesAggregationScanNode(
+            new PlanNodeId(id),
+            (AlignedPath) path,
+            aggregationDescriptors,
+            Ordering.ASC,
+            groupByTimeParameter);
+    aggregationScanNode.setOutputEndTime(outputEndTime);
+    aggregationScanNode.setPushDownPredicate(pushDownPredicate);
+    this.root = aggregationScanNode;
+    return this;
+  }
+
   public TestPlanBuilder rawDataAggregation(
       String id,
       List<AggregationDescriptor> aggregationDescriptors,

From 41f0b024a4505c05d2909360b1ae906fc6040b4f Mon Sep 17 00:00:00 2001
From: Minghui Liu <liuminghui233@foxmail.com>
Date: Tue, 14 May 2024 09:58:12 +0800
Subject: [PATCH 10/28] fix IT

---
 .../optimization/AggregationPushDown.java     | 30 +++++++++++++++++--
 .../optimization/AggregationPushDownTest.java |  2 +-
 2 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index a9a7a111919f..a5822e981cf8 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -28,6 +28,7 @@
 import org.apache.iotdb.db.queryengine.common.MPPQueryContext;
 import org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant;
 import org.apache.iotdb.db.queryengine.plan.analyze.Analysis;
+import org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer;
 import org.apache.iotdb.db.queryengine.plan.analyze.PredicateUtils;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimeSeriesOperand;
@@ -65,9 +66,11 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import static com.google.common.base.Preconditions.checkState;
 import static org.apache.iotdb.db.utils.constant.SqlConstant.COUNT_TIME;
@@ -274,9 +277,16 @@ public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterCon
         if (isSingleSource && ((SeriesScanSourceNode) child).getPushDownPredicate() != null) {
           Expression pushDownPredicate = ((SeriesScanSourceNode) child).getPushDownPredicate();
           sourceNodeList.forEach(
-              sourceNode ->
-                  ((SeriesAggregationSourceNode) sourceNode)
-                      .setPushDownPredicate(pushDownPredicate));
+              sourceNode -> {
+                SeriesAggregationSourceNode aggregationSourceNode =
+                    (SeriesAggregationSourceNode) sourceNode;
+                aggregationSourceNode.setPushDownPredicate(pushDownPredicate);
+                if (aggregationSourceNode instanceof AlignedSeriesAggregationScanNode) {
+                  extendAlignedPath(
+                      ((AlignedSeriesAggregationScanNode) aggregationSourceNode).getAlignedPath(),
+                      pushDownPredicate);
+                }
+              });
         }
 
         PlanNode resultNode = convergeWithTimeJoin(sourceNodeList, node.getScanOrder(), context);
@@ -418,6 +428,20 @@ private SeriesAggregationSourceNode createAggregationScanNode(
       }
     }
 
+    private void extendAlignedPath(AlignedPath alignedPath, Expression pushDownPredicate) {
+      Set<PartialPath> sourcePathsInPredicate =
+          ExpressionAnalyzer.searchSourceExpressions(pushDownPredicate).stream()
+              .map(expression -> ((TimeSeriesOperand) expression).getPath())
+              .collect(Collectors.toSet());
+      Set<String> existingMeasurements = new HashSet<>(alignedPath.getMeasurementList());
+      for (PartialPath sourcePath : sourcePathsInPredicate) {
+        if (!existingMeasurements.contains(sourcePath.getMeasurement())) {
+          alignedPath.addMeasurement((MeasurementPath) sourcePath);
+          existingMeasurements.add(sourcePath.getMeasurement());
+        }
+      }
+    }
+
     private PlanNode convergeWithTimeJoin(
         List<PlanNode> sourceNodes, Ordering mergeOrder, RewriterContext context) {
       PlanNode tmpNode;
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDownTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDownTest.java
index 75655f68e648..d8e92ab36252 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDownTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDownTest.java
@@ -272,7 +272,7 @@ public void testRemoveProject() {
         new TestPlanBuilder()
             .alignedAggregationScan(
                 "4",
-                schemaMap.get("aligned_root.sg.d2.a.s1"),
+                schemaMap.get("root.sg.d2.a"),
                 aggregationDescriptorList1,
                 groupByTimeParameter,
                 false,

From 884dccaf2dca8a2ad99e57938f55f396068ae59a Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Tue, 14 May 2024 10:28:31 +0800
Subject: [PATCH 11/28] not support agg(*) or agg(s1+1) now; perfect serialize
 method of RawDataAggregation

---
 .../plan/analyze/ExpressionTypeAnalyzer.java  | 11 +++-
 .../analyze/TemplatedAggregationAnalyze.java  | 56 ++++++++++++++++--
 .../plan/analyze/TemplatedAnalyze.java        |  4 +-
 .../plan/optimization/PredicatePushDown.java  | 14 +++--
 .../plan/planner/LogicalPlanBuilder.java      |  3 +-
 .../plan/planner/OperatorTreeGenerator.java   | 31 ++++++++--
 .../planner/TemplatedLogicalPlanBuilder.java  |  3 +-
 .../plan/planner/plan/PlanFragment.java       |  2 +-
 .../planner/plan/node/process/FilterNode.java | 59 +++++++++++++++----
 9 files changed, 153 insertions(+), 30 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
index 4abc81a04aad..6868b6122744 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
@@ -100,7 +100,16 @@ public static void analyzeExpressionUsingTemplatedInfo(
       Expression expression,
       TemplatedInfo templatedInfo) {
     ExpressionTypeAnalyzer analyzer = new ExpressionTypeAnalyzer();
-    analyzer.analyze(expression, templatedInfo.getSchemaMap());
+
+    Map<String, IMeasurementSchema> schemaMap = templatedInfo.getSchemaMap();
+    if (schemaMap == null) {
+      schemaMap = new LinkedHashMap<>();
+      for (int i = 0; i < templatedInfo.getMeasurementList().size(); i++) {
+        schemaMap.put(
+            templatedInfo.getMeasurementList().get(i), templatedInfo.getSchemaList().get(i));
+      }
+    }
+    analyzer.analyze(expression, schemaMap);
 
     types.putAll(analyzer.getExpressionTypes());
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index e9491eb0904f..27b9f17ccaef 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -19,6 +19,7 @@
 package org.apache.iotdb.db.queryengine.plan.analyze;
 
 import org.apache.iotdb.commons.path.PartialPath;
+import org.apache.iotdb.db.exception.sql.SemanticException;
 import org.apache.iotdb.db.queryengine.common.MPPQueryContext;
 import org.apache.iotdb.db.queryengine.common.schematree.ISchemaTree;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
@@ -27,6 +28,7 @@
 import org.apache.iotdb.db.queryengine.plan.statement.crud.QueryStatement;
 import org.apache.iotdb.db.schemaengine.template.Template;
 
+import org.apache.tsfile.enums.TSDataType;
 import org.apache.tsfile.utils.Pair;
 import org.apache.tsfile.write.schema.IMeasurementSchema;
 
@@ -40,6 +42,8 @@
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.END_TIME_EXPRESSION;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeExpressionType;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeOutput;
+import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.normalizeExpression;
+import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.searchAggregationExpressions;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDataPartition;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDeviceToWhere;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDeviceViewInput;
@@ -51,7 +55,7 @@
 /** Methods in this class are used for aggregation, templated with align by device situation. */
 public class TemplatedAggregationAnalyze {
 
-  static boolean analyzeAggregation(
+  static boolean canBuildAggregationPlanUseTemplate(
       Analysis analysis,
       QueryStatement queryStatement,
       IPartitionFetcher partitionFetcher,
@@ -69,7 +73,10 @@ static boolean analyzeAggregation(
     }
 
     List<Pair<Expression, String>> outputExpressions = new ArrayList<>();
-    analyzeSelect(queryStatement, analysis, outputExpressions, template);
+    boolean valid = analyzeSelect(queryStatement, analysis, outputExpressions, template);
+    if (!valid) {
+      return false;
+    }
 
     analyzeDeviceToWhere(analysis, queryStatement);
     if (deviceList.isEmpty()) {
@@ -85,6 +92,8 @@ static boolean analyzeAggregation(
       return true;
     }
 
+    analyzeHaving(analysis, queryStatement, schemaTree, deviceList);
+
     analyzeDeviceToAggregation(analysis);
     analyzeDeviceToSourceTransform(analysis);
     analyzeDeviceToSource(analysis);
@@ -101,7 +110,7 @@ static boolean analyzeAggregation(
     return true;
   }
 
-  private static void analyzeSelect(
+  private static boolean analyzeSelect(
       QueryStatement queryStatement,
       Analysis analysis,
       List<Pair<Expression, String>> outputExpressions,
@@ -142,8 +151,9 @@ private static void analyzeSelect(
 
       String measurement = selectExpression.getExpressions().get(0).getOutputSymbol();
       if (!template.getSchemaMap().containsKey(measurement)) {
-        throw new IllegalArgumentException(
-            "Measurement " + measurement + " is not found in template");
+        analysis.setDeviceTemplate(null);
+        // TODO not support agg(*) or agg(s1+1) now
+        return false;
       }
 
       // for agg1(s1) + agg2(s1), only record s1 for one time
@@ -161,6 +171,42 @@ private static void analyzeSelect(
     analysis.setAggregationExpressions(aggregationExpressions);
     analysis.setOutputExpressions(outputExpressions);
     analysis.setSelectExpressions(selectExpressions);
+    return true;
+  }
+
+  private static void analyzeHaving(
+      Analysis analysis,
+      QueryStatement queryStatement,
+      ISchemaTree schemaTree,
+      List<PartialPath> deviceSet) {
+    if (!queryStatement.hasHaving()) {
+      return;
+    }
+
+    // TODO not support having count(s1) + sum(s2) expression
+    Set<Expression> aggregationExpressions = analysis.getAggregationExpressions();
+
+    Expression havingExpression = queryStatement.getHavingCondition().getPredicate();
+
+    // Set<Expression> normalizedAggregationExpressions = new LinkedHashSet<>();
+    for (Expression aggregationExpression : searchAggregationExpressions(havingExpression)) {
+      Expression normalizedAggregationExpression = normalizeExpression(aggregationExpression);
+
+      analyzeExpressionType(analysis, aggregationExpression);
+      analyzeExpressionType(analysis, normalizedAggregationExpression);
+
+      aggregationExpressions.add(aggregationExpression);
+      // normalizedAggregationExpressions.add(normalizedAggregationExpression);
+    }
+
+    TSDataType outputType = analyzeExpressionType(analysis, havingExpression);
+    if (outputType != TSDataType.BOOLEAN) {
+      throw new SemanticException(
+          String.format(
+              "The output type of the expression in HAVING clause should be BOOLEAN, actual data type: %s.",
+              outputType));
+    }
+    analysis.setHavingExpression(havingExpression);
   }
 
   private static void analyzeDeviceToSourceTransform(Analysis analysis) {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
index a9a168e8cf27..2c4ca5d9e82c 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
@@ -71,7 +71,7 @@
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.concatDeviceAndBindSchemaForExpression;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.getMeasurementExpression;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionTypeAnalyzer.analyzeExpressionForTemplatedQuery;
-import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAggregationAnalyze.analyzeAggregation;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAggregationAnalyze.canBuildAggregationPlanUseTemplate;
 
 /**
  * This class provides accelerated implementation for multiple devices align by device query. This
@@ -113,7 +113,7 @@ public static boolean canBuildPlanUseTemplate(
     Template template = templates.get(0);
 
     if (queryStatement.isAggregationQuery()) {
-      return analyzeAggregation(
+      return canBuildAggregationPlanUseTemplate(
           analysis, queryStatement, partitionFetcher, schemaTree, context, template);
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java
index 7c8c93c18147..65a7023bb311 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java
@@ -164,7 +164,10 @@ public PlanNode visitFullOuterTimeJoin(FullOuterTimeJoinNode node, RewriterConte
       if (!cannotPushDownConjuncts.isEmpty()) {
         resultNode =
             planFilter(
-                resultNode, PredicateUtils.combineConjuncts(cannotPushDownConjuncts), context);
+                resultNode,
+                PredicateUtils.combineConjuncts(cannotPushDownConjuncts),
+                context,
+                true);
       } else {
         resultNode = planTransform(resultNode, context);
         resultNode = planProject(resultNode, context);
@@ -249,7 +252,8 @@ private PlanNode planLeftOuterTimeJoin(
       return resultNode;
     }
 
-    private PlanNode planFilter(PlanNode child, Expression predicate, RewriterContext context) {
+    private PlanNode planFilter(
+        PlanNode child, Expression predicate, RewriterContext context, boolean isFromWhere) {
       FilterNode pushDownFilterNode = context.getPushDownFilterNode();
       return new FilterNode(
           context.genPlanNodeId(),
@@ -257,7 +261,8 @@ private PlanNode planFilter(PlanNode child, Expression predicate, RewriterContex
           pushDownFilterNode.getOutputExpressions(),
           predicate,
           pushDownFilterNode.isKeepNull(),
-          pushDownFilterNode.getScanOrder());
+          pushDownFilterNode.getScanOrder(),
+          isFromWhere);
     }
 
     @Override
@@ -330,7 +335,8 @@ public PlanNode visitSeriesScanSource(SeriesScanSourceNode node, RewriterContext
         resultNode = planProject(resultNode, context);
         return resultNode;
       } else {
-        return planFilter(node, PredicateUtils.combineConjuncts(cannotPushDownConjuncts), context);
+        return planFilter(
+            node, PredicateUtils.combineConjuncts(cannotPushDownConjuncts), context, true);
       }
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
index 7ce23590e23b..5ae949b63eac 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
@@ -880,7 +880,8 @@ public LogicalPlanBuilder planFilterAndTransform(
             selectExpressions.toArray(new Expression[0]),
             filterExpression,
             isGroupByTime,
-            scanOrder);
+            scanOrder,
+            fromWhere);
     if (fromWhere) {
       analysis.setFromWhere(filterNode);
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
index c156757729f8..ecd6b0963096 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
@@ -495,10 +495,11 @@ public Operator visitProject(ProjectNode node, LocalExecutionPlanContext context
     List<String> outputColumnNames = node.getOutputColumnNames();
     if (outputColumnNames == null) {
       if (context.getTypeProvider().getTemplatedInfo().aggregationDescriptorList != null) {
+        // TODO fix it
         // outputColumnNames is aggregation expression
         outputColumnNames = context.getTypeProvider().getTemplatedInfo().getDeviceViewOutputNames();
         outputColumnNames = outputColumnNames.subList(1, outputColumnNames.size());
-        inputColumnNames = context.getTypeProvider().getTemplatedInfo().getMeasurementList();
+        inputColumnNames = outputColumnNames;
       } else {
         outputColumnNames = context.getTypeProvider().getTemplatedInfo().getDeviceViewOutputNames();
         // skip device column
@@ -1436,7 +1437,7 @@ public Operator visitTransform(TransformNode node, LocalExecutionPlanContext con
 
   @Override
   public Operator visitFilter(FilterNode node, LocalExecutionPlanContext context) {
-    if (context.isBuildPlanUseTemplate()) {
+    if (context.isBuildPlanUseTemplate() && node.isFromWhere()) {
       TemplatedInfo templatedInfo = context.getTemplatedInfo();
       return constructFilterOperator(
           node.getPredicate(),
@@ -1450,11 +1451,18 @@ public Operator visitFilter(FilterNode node, LocalExecutionPlanContext context)
           context);
     }
 
+    // 1. not use template
+    // 2. use template but the FilterNode is not generated by FilterNode
+    // the inputDataTypes should be generated by the outputColumns of children
     return constructFilterOperator(
         node.getPredicate(),
         generateOnlyChildOperator(node, context),
         node.getOutputExpressions(),
-        getInputColumnTypes(node, context.getTypeProvider()),
+        node.getChildren().stream()
+            .map(PlanNode::getOutputColumnNames)
+            .flatMap(List::stream)
+            .map(context.getTypeProvider()::getType)
+            .collect(Collectors.toList()),
         makeLayout(node),
         node.isKeepNull(),
         node.getPlanNodeId(),
@@ -1819,13 +1827,28 @@ public Operator visitOffset(OffsetNode node, LocalExecutionPlanContext context)
   @Override
   public Operator visitRawDataAggregation(
       RawDataAggregationNode node, LocalExecutionPlanContext context) {
+    // TODO optimize serialize and deserialize method in template situation
+    Map<String, List<InputLocation>> layout;
+    if (context.isBuildPlanUseTemplate()) {
+      // in template situation, output columns of ProjectNode is not stored, it's same as its
+      // children
+      layout = context.getTemplatedInfo().getLayoutMap();
+    } else {
+      layout = makeLayout(node);
+    }
+    return createRawDataAggregationOperator(node, context, layout);
+  }
+
+  private RawDataAggregationOperator createRawDataAggregationOperator(
+      RawDataAggregationNode node,
+      LocalExecutionPlanContext context,
+      Map<String, List<InputLocation>> layout) {
     checkArgument(
         !node.getAggregationDescriptorList().isEmpty(),
         "Aggregation descriptorList cannot be empty");
     Operator child = node.getChild().accept(this, context);
     boolean ascending = node.getScanOrder() == Ordering.ASC;
     List<Aggregator> aggregators = new ArrayList<>();
-    Map<String, List<InputLocation>> layout = makeLayout(node);
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
     for (AggregationDescriptor descriptor : node.getAggregationDescriptorList()) {
       List<InputLocation[]> inputLocationList = calcInputLocationList(descriptor, layout);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
index 1cae21e89219..8062172acb21 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
@@ -128,7 +128,8 @@ public TemplatedLogicalPlanBuilder planFilter(
             null,
             filterExpression,
             isGroupByTime,
-            scanOrder);
+            scanOrder,
+            true);
     analysis.setFromWhere(filterNode);
 
     this.root = filterNode;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
index e9e18ef9548c..3b32f2932cb6 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
@@ -153,7 +153,7 @@ public void serialize(DataOutputStream stream) throws IOException {
     } else {
       ReadWriteIOUtils.write((byte) 1, stream);
 
-      // templated device, the serialized attribute basically same,
+      // templated align by device query, the serialized attributes are same,
       // so there is no need to serialize all the SeriesScanNode repeated
       if (typeProvider.getTemplatedInfo() != null) {
         typeProvider.serialize(stream);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/FilterNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/FilterNode.java
index f57466c98a0c..f121eec96f90 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/FilterNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/FilterNode.java
@@ -37,15 +37,21 @@ public class FilterNode extends TransformNode {
 
   private final Expression predicate;
 
+  // whether this node is generated by where clause
+  // fromWhere equals false, means it is generated by having clause
+  private final boolean fromWhere;
+
   public FilterNode(
       PlanNodeId id,
       PlanNode childPlanNode,
       Expression[] outputExpressions,
       Expression predicate,
       boolean keepNull,
-      Ordering scanOrder) {
+      Ordering scanOrder,
+      boolean fromWhere) {
     super(id, childPlanNode, outputExpressions, keepNull, scanOrder);
     this.predicate = predicate;
+    this.fromWhere = fromWhere;
   }
 
   /** This construction method is only used in inner of class `FilterNode`. */
@@ -54,9 +60,11 @@ public FilterNode(
       Expression[] outputExpressions,
       Expression predicate,
       boolean keepNull,
-      Ordering scanOrder) {
+      Ordering scanOrder,
+      boolean fromWhere) {
     super(id, outputExpressions, keepNull, scanOrder);
     this.predicate = predicate;
+    this.fromWhere = fromWhere;
   }
 
   @Override
@@ -71,7 +79,8 @@ public PlanNodeType getType() {
 
   @Override
   public PlanNode clone() {
-    return new FilterNode(getPlanNodeId(), outputExpressions, predicate, keepNull, scanOrder);
+    return new FilterNode(
+        getPlanNodeId(), outputExpressions, predicate, keepNull, scanOrder, fromWhere);
   }
 
   @Override
@@ -108,7 +117,7 @@ public static FilterNode deserialize(ByteBuffer byteBuffer) {
     boolean keepNull = ReadWriteIOUtils.readBool(byteBuffer);
     Ordering scanOrder = Ordering.values()[ReadWriteIOUtils.readInt(byteBuffer)];
     PlanNodeId planNodeId = PlanNodeId.deserialize(byteBuffer);
-    return new FilterNode(planNodeId, outputExpressions, predicate, keepNull, scanOrder);
+    return new FilterNode(planNodeId, outputExpressions, predicate, keepNull, scanOrder, false);
   }
 
   @Override
@@ -116,6 +125,17 @@ public void serializeUseTemplate(DataOutputStream stream, TypeProvider typeProvi
       throws IOException {
     PlanNodeType.FILTER.serialize(stream);
     id.serialize(stream);
+    ReadWriteIOUtils.write(fromWhere, stream);
+    // for FilterNode generated by having clause, it must be serialized totally
+    if (!fromWhere) {
+      ReadWriteIOUtils.write(outputExpressions.length, stream);
+      for (Expression expression : outputExpressions) {
+        Expression.serialize(expression, stream);
+      }
+      Expression.serialize(predicate, stream);
+      ReadWriteIOUtils.write(keepNull, stream);
+      ReadWriteIOUtils.write(scanOrder.ordinal(), stream);
+    }
     ReadWriteIOUtils.write(getChildren().size(), stream);
     for (PlanNode planNode : getChildren()) {
       planNode.serializeUseTemplate(stream, typeProvider);
@@ -125,13 +145,26 @@ public void serializeUseTemplate(DataOutputStream stream, TypeProvider typeProvi
   public static FilterNode deserializeUseTemplate(
       ByteBuffer byteBuffer, TypeProvider typeProvider) {
     PlanNodeId planNodeId = PlanNodeId.deserialize(byteBuffer);
-
-    return new FilterNode(
-        planNodeId,
-        null,
-        typeProvider.getTemplatedInfo().getPredicate(),
-        typeProvider.getTemplatedInfo().isKeepNull(),
-        typeProvider.getTemplatedInfo().getScanOrder());
+    boolean fromWhere = ReadWriteIOUtils.readBool(byteBuffer);
+    if (!fromWhere) {
+      int outputExpressionsLength = ReadWriteIOUtils.readInt(byteBuffer);
+      Expression[] outputExpressions = new Expression[outputExpressionsLength];
+      for (int i = 0; i < outputExpressionsLength; ++i) {
+        outputExpressions[i] = Expression.deserialize(byteBuffer);
+      }
+      Expression predicate = Expression.deserialize(byteBuffer);
+      boolean keepNull = ReadWriteIOUtils.readBool(byteBuffer);
+      Ordering scanOrder = Ordering.values()[ReadWriteIOUtils.readInt(byteBuffer)];
+      return new FilterNode(planNodeId, outputExpressions, predicate, keepNull, scanOrder, false);
+    } else {
+      return new FilterNode(
+          planNodeId,
+          null,
+          typeProvider.getTemplatedInfo().getPredicate(),
+          typeProvider.getTemplatedInfo().isKeepNull(),
+          typeProvider.getTemplatedInfo().getScanOrder(),
+          true);
+    }
   }
 
   public Expression getPredicate() {
@@ -142,6 +175,10 @@ public void setOutputExpressions(Expression[] outputExpressions) {
     this.outputExpressions = outputExpressions;
   }
 
+  public boolean isFromWhere() {
+    return fromWhere;
+  }
+
   @Override
   public String toString() {
     return "FilterNode-" + this.getPlanNodeId();

From 613a3442ce114ca722fe01b6adfcb070344d9f7f Mon Sep 17 00:00:00 2001
From: Minghui Liu <liuminghui233@foxmail.com>
Date: Tue, 14 May 2024 11:06:34 +0800
Subject: [PATCH 12/28] fix extend aligned path

---
 .../optimization/AggregationPushDown.java     | 23 +++----------------
 .../AlignedSeriesAggregationScanNode.java     |  6 ++++-
 2 files changed, 8 insertions(+), 21 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index a5822e981cf8..cf4b34619551 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -28,7 +28,6 @@
 import org.apache.iotdb.db.queryengine.common.MPPQueryContext;
 import org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant;
 import org.apache.iotdb.db.queryengine.plan.analyze.Analysis;
-import org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer;
 import org.apache.iotdb.db.queryengine.plan.analyze.PredicateUtils;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimeSeriesOperand;
@@ -47,6 +46,7 @@
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.SlidingWindowAggregationNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.join.FullOuterTimeJoinNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.AlignedSeriesAggregationScanNode;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.AlignedSeriesScanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.SeriesAggregationScanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.SeriesAggregationSourceNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.SeriesScanSourceNode;
@@ -66,11 +66,9 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 import static com.google.common.base.Preconditions.checkState;
 import static org.apache.iotdb.db.utils.constant.SqlConstant.COUNT_TIME;
@@ -282,9 +280,8 @@ public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterCon
                     (SeriesAggregationSourceNode) sourceNode;
                 aggregationSourceNode.setPushDownPredicate(pushDownPredicate);
                 if (aggregationSourceNode instanceof AlignedSeriesAggregationScanNode) {
-                  extendAlignedPath(
-                      ((AlignedSeriesAggregationScanNode) aggregationSourceNode).getAlignedPath(),
-                      pushDownPredicate);
+                  ((AlignedSeriesAggregationScanNode) aggregationSourceNode)
+                      .setAlignedPath(((AlignedSeriesScanNode) child).getAlignedPath());
                 }
               });
         }
@@ -428,20 +425,6 @@ private SeriesAggregationSourceNode createAggregationScanNode(
       }
     }
 
-    private void extendAlignedPath(AlignedPath alignedPath, Expression pushDownPredicate) {
-      Set<PartialPath> sourcePathsInPredicate =
-          ExpressionAnalyzer.searchSourceExpressions(pushDownPredicate).stream()
-              .map(expression -> ((TimeSeriesOperand) expression).getPath())
-              .collect(Collectors.toSet());
-      Set<String> existingMeasurements = new HashSet<>(alignedPath.getMeasurementList());
-      for (PartialPath sourcePath : sourcePathsInPredicate) {
-        if (!existingMeasurements.contains(sourcePath.getMeasurement())) {
-          alignedPath.addMeasurement((MeasurementPath) sourcePath);
-          existingMeasurements.add(sourcePath.getMeasurement());
-        }
-      }
-    }
-
     private PlanNode convergeWithTimeJoin(
         List<PlanNode> sourceNodes, Ordering mergeOrder, RewriterContext context) {
       PlanNode tmpNode;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
index 06392041ed93..2b69cdb0bc49 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
@@ -49,7 +49,7 @@
 public class AlignedSeriesAggregationScanNode extends SeriesAggregationSourceNode {
 
   // The paths of the target series which will be aggregated.
-  private final AlignedPath alignedPath;
+  private AlignedPath alignedPath;
 
   // The id of DataRegion where the node will run
   private TRegionReplicaSet regionReplicaSet;
@@ -112,6 +112,10 @@ public AlignedPath getAlignedPath() {
     return alignedPath;
   }
 
+  public void setAlignedPath(AlignedPath alignedPath) {
+    this.alignedPath = alignedPath;
+  }
+
   @Override
   public Ordering getScanOrder() {
     return scanOrder;

From 303df4bc86184e61535a63db73ce4db1ac2920ac Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Tue, 14 May 2024 11:50:34 +0800
Subject: [PATCH 13/28] fix ut

---
 .../plan/optimization/TestPlanBuilder.java     |  3 ++-
 .../logical/DataQueryLogicalPlannerTest.java   | 18 ++++++++++++------
 .../node/process/FilterNodeSerdeTest.java      |  3 ++-
 3 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java
index b5f82ddc7a62..17b19210a77c 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java
@@ -345,7 +345,8 @@ public TestPlanBuilder filter(
             expressions.toArray(new Expression[0]),
             predicate,
             isGroupByTime,
-            Ordering.ASC);
+            Ordering.ASC,
+            true);
     return this;
   }
 
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/DataQueryLogicalPlannerTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/DataQueryLogicalPlannerTest.java
index adb25ea1a009..2a14c0cf3b2b 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/DataQueryLogicalPlannerTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/DataQueryLogicalPlannerTest.java
@@ -194,7 +194,8 @@ public void testRawDataQuery() {
             new Expression[] {new TimeSeriesOperand(schemaMap.get("root.sg.d2.s1"))},
             predicate,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     OffsetNode offsetNode = new OffsetNode(queryId.genPlanNodeId(), filterNode, 100);
     LimitNode limitNode = new LimitNode(queryId.genPlanNodeId(), offsetNode, 100);
@@ -249,7 +250,8 @@ public void testRawDataQueryAlignByDevice() {
             },
             predicate1,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     List<PlanNode> sourceNodeList2 = new ArrayList<>();
     sourceNodeList2.add(
@@ -287,7 +289,8 @@ public void testRawDataQueryAlignByDevice() {
             },
             predicate2,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     Map<String, List<Integer>> deviceToMeasurementIndexesMap = new HashMap<>();
     deviceToMeasurementIndexesMap.put("root.sg.d1", Arrays.asList(1, 2, 3));
@@ -742,7 +745,8 @@ public void testAggregationQueryWithValueFilter() {
             },
             predicate,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     RawDataAggregationNode aggregationNode =
         new RawDataAggregationNode(
@@ -867,7 +871,8 @@ public void testAggregationQueryWithValueFilterAlignByDevice() {
             },
             predicate1,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     RawDataAggregationNode aggregationNode1 =
         new RawDataAggregationNode(
@@ -922,7 +927,8 @@ public void testAggregationQueryWithValueFilterAlignByDevice() {
             },
             predicate2,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     RawDataAggregationNode aggregationNode2 =
         new RawDataAggregationNode(
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/node/process/FilterNodeSerdeTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/node/process/FilterNodeSerdeTest.java
index ad5e28f27b38..998df88719b4 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/node/process/FilterNodeSerdeTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/node/process/FilterNodeSerdeTest.java
@@ -52,7 +52,8 @@ public void testSerializeAndDeserialize() throws IllegalPathException {
                 new TimeSeriesOperand(new PartialPath("root.sg.d1.s1")),
                 new ConstantOperand(TSDataType.INT64, "100")),
             false,
-            Ordering.ASC);
+            Ordering.ASC,
+            true);
 
     ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
     filterNode.serialize(byteBuffer);

From c8199d26f29c792f19d3fb1ca6e555d1b35a6e4e Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Tue, 14 May 2024 16:02:09 +0800
Subject: [PATCH 14/28] fix descending aggregator problem; add more comments

---
 .../java/org/apache/iotdb/SessionExample.java | 29 +------------------
 .../analyze/TemplatedAggregationAnalyze.java  |  2 +-
 .../optimization/AggregationPushDown.java     |  2 +-
 3 files changed, 3 insertions(+), 30 deletions(-)

diff --git a/example/session/src/main/java/org/apache/iotdb/SessionExample.java b/example/session/src/main/java/org/apache/iotdb/SessionExample.java
index e65127fd3883..0daec0885bf7 100644
--- a/example/session/src/main/java/org/apache/iotdb/SessionExample.java
+++ b/example/session/src/main/java/org/apache/iotdb/SessionExample.java
@@ -61,39 +61,12 @@ public class SessionExample {
   private static final String ROOT_SG1_D1 = "root.sg1.d1";
   private static final String ROOT_SG1 = "root.sg1";
   private static final String LOCAL_HOST = "127.0.0.1";
-  public static final String SELECT_D1 =
-      "select value from root.cmadaas_nafp_surf.nafp.NAFP_GRAPES_MESO_FOR_3KM.data.RHU.`100`.`100000`.tile limit 10";
+  public static final String SELECT_D1 = "select * from root.sg1.d1";
 
   private static Random random = new Random();
 
   public static void main(String[] args)
       throws IoTDBConnectionException, StatementExecutionException {
-    session =
-        new Session.Builder()
-            .host("172.20.31.60")
-            .port(6667)
-            .username("root")
-            .password("root")
-            .version(Version.V_1_0)
-            .build();
-    session.open(false);
-
-    // set session fetchSize
-    session.setFetchSize(10000);
-
-    long time1 = System.currentTimeMillis();
-    try (SessionDataSet dataSet = session.executeQueryStatement(SELECT_D1)) {
-      // System.out.println(dataSet.getColumnNames());
-      //      dataSet.setFetchSize(1024); // default is 10000
-      //      while (dataSet.hasNext()) {
-      //        System.out.println(dataSet.next());
-      //      }
-    }
-    System.out.println("Time: " + (System.currentTimeMillis() - time1));
-  }
-
-  public static void main1(String[] args)
-      throws IoTDBConnectionException, StatementExecutionException {
     session =
         new Session.Builder()
             .host(LOCAL_HOST)
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index 27b9f17ccaef..f0c9951fb60f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -152,7 +152,7 @@ private static boolean analyzeSelect(
       String measurement = selectExpression.getExpressions().get(0).getOutputSymbol();
       if (!template.getSchemaMap().containsKey(measurement)) {
         analysis.setDeviceTemplate(null);
-        // TODO not support agg(*) or agg(s1+1) now
+        // TODO not support agg(*), agg(s1+1), count_time(*) now
         return false;
       }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index 5c5d972fa851..2e65e7501937 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -456,7 +456,7 @@ private List<PlanNode> constructSourceNodeFromTemplateAggregationDescriptors(
                   alignedPath, aggregationDescriptors, scanOrder, groupByTimeParameter, context));
         }
 
-        if (needCheckAscending) {
+        if (needCheckAscending && !descendingAggregations.isEmpty()) {
           aggregationDescriptors =
               descendingAggregations.values().stream()
                   .flatMap(Collection::stream)

From c1b9f3a482f0e6f3b8ca0829ad9a8ab349d768e3 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Wed, 15 May 2024 08:47:14 +0800
Subject: [PATCH 15/28] fix group by time;  fix select agg1() having agg2()

---
 .../plan/analyze/AnalyzeVisitor.java          |  2 +-
 .../analyze/TemplatedAggregationAnalyze.java  |  6 ++-
 .../plan/analyze/TemplatedAnalyze.java        | 52 +++++++++++++++----
 .../plan/analyze/TemplatedInfo.java           | 34 +++++++++---
 .../plan/planner/OperatorTreeGenerator.java   |  6 +--
 .../plan/planner/SubPlanTypeExtractor.java    |  9 ++++
 .../plan/planner/TemplatedLogicalPlan.java    |  6 ++-
 .../planner/TemplatedLogicalPlanBuilder.java  |  7 +--
 .../plan/planner/plan/node/PlanNodeType.java  |  6 ++-
 .../plan/node/process/DeviceViewNode.java     | 47 +++++++++++++++++
 .../node/process/RawDataAggregationNode.java  | 20 +++++++
 .../AlignedSeriesAggregationScanNode.java     |  2 +-
 .../plan/parameter/GroupByTimeParameter.java  |  4 ++
 13 files changed, 170 insertions(+), 31 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
index 97166281d1a7..39a377303c2c 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
@@ -1866,7 +1866,7 @@ private void checkGroupByConditionExpressionType(
     }
   }
 
-  private void analyzeGroupByTime(Analysis analysis, QueryStatement queryStatement) {
+  static void analyzeGroupByTime(Analysis analysis, QueryStatement queryStatement) {
     if (!queryStatement.isGroupByTime()) {
       return;
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index f0c9951fb60f..cf19a791482f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -41,6 +41,7 @@
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.DEVICE_EXPRESSION;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.END_TIME_EXPRESSION;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeExpressionType;
+import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeGroupByTime;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeOutput;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.normalizeExpression;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.searchAggregationExpressions;
@@ -99,12 +100,14 @@ static boolean canBuildAggregationPlanUseTemplate(
     analyzeDeviceToSource(analysis);
 
     analyzeDeviceViewOutput(analysis, queryStatement);
-    analyzeDeviceViewInput(analysis);
+    analyzeDeviceViewInput(analysis, queryStatement);
 
     // generate result set header according to output expressions
     analyzeOutput(analysis, queryStatement, outputExpressions);
 
+    analyzeGroupByTime(analysis, queryStatement);
     context.generateGlobalTimeFilter(analysis);
+
     // fetch partition information
     analyzeDataPartition(analysis, schemaTree, partitionFetcher, context.getGlobalTimeFilter());
     return true;
@@ -215,7 +218,6 @@ private static void analyzeDeviceToSourceTransform(Analysis analysis) {
   }
 
   private static void analyzeDeviceToSource(Analysis analysis) {
-    // TODO add having into Source
     analysis.setDeviceToSourceExpressions(analysis.getDeviceToSelectExpressions());
     analysis.setDeviceToOutputExpressions(analysis.getDeviceToSelectExpressions());
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
index 2c4ca5d9e82c..bc14b2c55cdf 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
@@ -70,6 +70,7 @@
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.getTimePartitionSlotList;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.concatDeviceAndBindSchemaForExpression;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.getMeasurementExpression;
+import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.searchAggregationExpressions;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionTypeAnalyzer.analyzeExpressionForTemplatedQuery;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAggregationAnalyze.canBuildAggregationPlanUseTemplate;
 
@@ -97,8 +98,7 @@ public static boolean canBuildPlanUseTemplate(
       IPartitionFetcher partitionFetcher,
       ISchemaTree schemaTree,
       MPPQueryContext context) {
-    if (queryStatement.isGroupBy()
-        || (queryStatement.isGroupByTime() && !queryStatement.isAggregationQuery())
+    if (queryStatement.getGroupByComponent() != null
         || queryStatement.isSelectInto()
         || queryStatement.hasFill()
         || schemaTree.hasNormalTimeSeries()) {
@@ -191,7 +191,7 @@ public static boolean canBuildPlanUseTemplate(
     analyzeDeviceToSource(analysis);
 
     analyzeDeviceViewOutput(analysis, queryStatement);
-    analyzeDeviceViewInput(analysis);
+    analyzeDeviceViewInput(analysis, queryStatement);
 
     analyzeFill(analysis, queryStatement);
 
@@ -329,23 +329,53 @@ private static void analyzeDeviceToSourceTransform(Analysis analysis) {
 
   static void analyzeDeviceViewOutput(Analysis analysis, QueryStatement queryStatement) {
     Set<Expression> selectExpressions = analysis.getSelectExpressions();
-    // TODO if no order by, just set deviceViewOutputExpressions as selectExpressions
-    Set<Expression> deviceViewOutputExpressions = new LinkedHashSet<>(selectExpressions);
-    if (queryStatement.hasOrderByExpression()) {
-      deviceViewOutputExpressions.addAll(analysis.getOrderByExpressions());
+    // if no order by, just set deviceViewOutputExpressions as selectExpressions
+    Set<Expression> deviceViewOutputExpressions = new LinkedHashSet<>();
+
+    if (queryStatement.isAggregationQuery()) {
+      deviceViewOutputExpressions.add(DEVICE_EXPRESSION);
+      if (queryStatement.isOutputEndTime()) {
+        deviceViewOutputExpressions.add(END_TIME_EXPRESSION);
+      }
+      for (Expression selectExpression : selectExpressions) {
+        deviceViewOutputExpressions.addAll(searchAggregationExpressions(selectExpression));
+      }
+      if (queryStatement.hasHaving()) {
+        deviceViewOutputExpressions.addAll(
+            searchAggregationExpressions(analysis.getHavingExpression()));
+      }
+      if (queryStatement.hasOrderByExpression()) {
+        for (Expression orderByExpression : analysis.getOrderByExpressions()) {
+          deviceViewOutputExpressions.addAll(searchAggregationExpressions(orderByExpression));
+        }
+      }
+    } else {
+      deviceViewOutputExpressions.addAll(selectExpressions);
+      if (queryStatement.hasOrderByExpression()) {
+        deviceViewOutputExpressions.addAll(analysis.getOrderByExpressions());
+      }
     }
+
     analysis.setDeviceViewOutputExpressions(deviceViewOutputExpressions);
     analysis.setDeviceViewSpecialProcess(
         analyzeDeviceViewSpecialProcess(deviceViewOutputExpressions, queryStatement, analysis));
   }
 
-  static void analyzeDeviceViewInput(Analysis analysis) {
+  static void analyzeDeviceViewInput(Analysis analysis, QueryStatement queryStatement) {
     List<Integer> indexes = new ArrayList<>();
 
-    // index-0 is `Device`
-    for (int i = 1; i < analysis.getSelectExpressions().size(); i++) {
-      indexes.add(i);
+    if (queryStatement.isAggregationQuery()) {
+      // TODO verify the rightness of order
+      for (int i = 1; i <= analysis.getAggregationExpressions().size(); i++) {
+        indexes.add(i);
+      }
+    } else {
+      for (int i = 1; i < analysis.getSelectExpressions().size(); i++) {
+        indexes.add(i);
+      }
     }
+
+    // TODO only store once
     Map<String, List<Integer>> deviceViewInputIndexesMap = new HashMap<>();
     for (PartialPath devicePath : analysis.getDeviceList()) {
       deviceViewInputIndexesMap.put(devicePath.getFullPath(), indexes);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
index a0e5dc09d4f9..2ae63c12a90f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
@@ -73,7 +73,7 @@ public class TemplatedInfo {
 
   // utils variables, not serialize
   private Map<String, IMeasurementSchema> schemaMap;
-  private Map<String, List<InputLocation>> layoutMap;
+  private Map<String, List<InputLocation>> filterLayoutMap;
   private int maxTsBlockLineNum = -1;
 
   // variables related to predicate push down
@@ -100,7 +100,7 @@ public TemplatedInfo(
       Expression predicate,
       boolean keepNull,
       Map<String, IMeasurementSchema> schemaMap,
-      Map<String, List<InputLocation>> layoutMap,
+      Map<String, List<InputLocation>> filterLayoutMap,
       Expression pushDownPredicate,
       List<AggregationDescriptor> aggregationDescriptorList,
       GroupByTimeParameter groupByTimeParameter,
@@ -118,7 +118,7 @@ public TemplatedInfo(
     if (predicate != null) {
       this.keepNull = keepNull;
       this.schemaMap = schemaMap;
-      this.layoutMap = layoutMap;
+      this.filterLayoutMap = filterLayoutMap;
     }
     this.pushDownPredicate = pushDownPredicate;
 
@@ -175,8 +175,8 @@ public Map<String, IMeasurementSchema> getSchemaMap() {
     return this.schemaMap;
   }
 
-  public Map<String, List<InputLocation>> getLayoutMap() {
-    return this.layoutMap;
+  public Map<String, List<InputLocation>> getFilterLayoutMap() {
+    return this.filterLayoutMap;
   }
 
   public Expression getPushDownPredicate() {
@@ -266,6 +266,13 @@ public void serialize(ByteBuffer byteBuffer) {
     } else {
       ReadWriteIOUtils.write(0, byteBuffer);
     }
+
+    if (groupByTimeParameter != null) {
+      ReadWriteIOUtils.write((byte) 1, byteBuffer);
+      groupByTimeParameter.serialize(byteBuffer);
+    } else {
+      ReadWriteIOUtils.write((byte) 0, byteBuffer);
+    }
   }
 
   public void serialize(DataOutputStream stream) throws IOException {
@@ -318,6 +325,13 @@ public void serialize(DataOutputStream stream) throws IOException {
     } else {
       ReadWriteIOUtils.write(0, stream);
     }
+
+    if (groupByTimeParameter != null) {
+      ReadWriteIOUtils.write((byte) 1, stream);
+      groupByTimeParameter.serialize(stream);
+    } else {
+      ReadWriteIOUtils.write((byte) 0, stream);
+    }
   }
 
   public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
@@ -392,7 +406,13 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
       }
     }
 
-    // TODO add groupByTimeParameter, outputEndTime serialization and deserialization
+    byte hasGroupByTime = ReadWriteIOUtils.readByte(byteBuffer);
+    GroupByTimeParameter groupByTimeParameter = null;
+    if (hasGroupByTime == 1) {
+      groupByTimeParameter = GroupByTimeParameter.deserialize(byteBuffer);
+    }
+
+    // TODO add outputEndTime serialization and deserialization
 
     return new TemplatedInfo(
         measurementList,
@@ -410,7 +430,7 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
         layoutMap,
         pushDownPredicate,
         aggregationDescriptorList,
-        null,
+        groupByTimeParameter,
         false);
   }
 }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
index ecd6b0963096..6b2ecccfd65a 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
@@ -447,7 +447,7 @@ public Operator visitAlignedSeriesScan(
             seriesScanOperator,
             templatedInfo.getProjectExpressions(),
             templatedInfo.getDataTypes(),
-            templatedInfo.getLayoutMap(),
+            templatedInfo.getFilterLayoutMap(),
             templatedInfo.isKeepNull(),
             node.getPlanNodeId(),
             templatedInfo.getScanOrder(),
@@ -1444,7 +1444,7 @@ public Operator visitFilter(FilterNode node, LocalExecutionPlanContext context)
           generateOnlyChildOperator(node, context),
           templatedInfo.getProjectExpressions(),
           templatedInfo.getDataTypes(),
-          templatedInfo.getLayoutMap(),
+          templatedInfo.getFilterLayoutMap(),
           templatedInfo.isKeepNull(),
           node.getPlanNodeId(),
           templatedInfo.getScanOrder(),
@@ -1832,7 +1832,7 @@ public Operator visitRawDataAggregation(
     if (context.isBuildPlanUseTemplate()) {
       // in template situation, output columns of ProjectNode is not stored, it's same as its
       // children
-      layout = context.getTemplatedInfo().getLayoutMap();
+      layout = context.getTemplatedInfo().getFilterLayoutMap();
     } else {
       layout = makeLayout(node);
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/SubPlanTypeExtractor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/SubPlanTypeExtractor.java
index b8efa1e3b3d2..34d48ea8a72b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/SubPlanTypeExtractor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/SubPlanTypeExtractor.java
@@ -85,6 +85,13 @@ public Void visitSeriesAggregationScan(SeriesAggregationScanNode node, Void cont
     @Override
     public Void visitAlignedSeriesAggregationScan(
         AlignedSeriesAggregationScanNode node, Void context) {
+      // if TemplateInfo is not empty, all type infos used by AlignedSeriesAggregationScanNode have
+      // been stored
+      // in TemplateInfo
+      if (typeProvider.getTemplatedInfo() != null) {
+        return null;
+      }
+
       AlignedPath alignedPath = node.getAlignedPath();
       for (int i = 0; i < alignedPath.getColumnNum(); i++) {
         String sourcePath = alignedPath.getPathWithMeasurement(i).getFullPath();
@@ -168,6 +175,7 @@ public Void visitSingleDeviceView(SingleDeviceViewNode node, Void context) {
       if (typeProvider.getTemplatedInfo() != null) {
         return null;
       }
+
       return visitPlan(node, context);
     }
 
@@ -178,6 +186,7 @@ public Void visitFilter(FilterNode node, Void context) {
       if (typeProvider.getTemplatedInfo() != null) {
         return null;
       }
+
       return visitPlan(node, context);
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
index 8242c3385449..a00aee711d70 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
@@ -51,6 +51,7 @@
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedInfo.makeLayout;
 import static org.apache.iotdb.db.queryengine.plan.planner.LogicalPlanBuilder.updateTypeProviderByPartialAggregation;
 import static org.apache.iotdb.db.queryengine.plan.planner.LogicalPlanVisitor.pushDownLimitToScanNode;
+import static org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.AggregationNode.getDeduplicatedDescriptors;
 
 /**
  * This class provides accelerated implementation for multiple devices align by device query. This
@@ -81,6 +82,8 @@ public class TemplatedLogicalPlan {
 
   List<AggregationDescriptor> aggregationDescriptorList;
 
+  List<AggregationDescriptor> deduplicatedDescriptors;
+
   public TemplatedLogicalPlan(
       Analysis analysis, QueryStatement queryStatement, MPPQueryContext context) {
     this.analysis = analysis;
@@ -324,6 +327,7 @@ private PlanNode visitAggregation() {
     LogicalPlanBuilder planBuilder =
         new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList);
     Map<String, PlanNode> deviceToSubPlanMap = new LinkedHashMap<>();
+    deduplicatedDescriptors = getDeduplicatedDescriptors(aggregationDescriptorList);
     for (PartialPath devicePath : analysis.getDeviceList()) {
       String deviceName = devicePath.getFullPath();
       PlanNode rootNode = visitDeviceAggregationBody(devicePath, curStep);
@@ -395,7 +399,7 @@ private PlanNode visitDeviceAggregationBody(PartialPath devicePath, AggregationS
             queryStatement.isOutputEndTime(),
             curStep,
             queryStatement.getResultTimeOrder(),
-            aggregationDescriptorList);
+            deduplicatedDescriptors);
 
     if (queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap()) {
       planBuilder =
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
index 8062172acb21..3ee79317753c 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
@@ -147,7 +147,7 @@ public TemplatedLogicalPlanBuilder planRawDataAggregation(
       boolean outputEndTime,
       AggregationStep curStep,
       Ordering scanOrder,
-      List<AggregationDescriptor> aggregationDescriptorList) {
+      List<AggregationDescriptor> deduplicatedAggregationDescriptorList) {
     if (aggregationExpressions == null) {
       return this;
     }
@@ -156,12 +156,13 @@ public TemplatedLogicalPlanBuilder planRawDataAggregation(
         new RawDataAggregationNode(
             context.getQueryId().genPlanNodeId(),
             this.getRoot(),
-            aggregationDescriptorList,
+            deduplicatedAggregationDescriptorList,
             groupByTimeParameter,
             groupByParameter,
             groupByExpression,
             outputEndTime,
-            scanOrder);
+            scanOrder,
+            true);
     return this;
   }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java
index 109a9a811975..2b5e665a755b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java
@@ -470,16 +470,18 @@ public static PlanNode deserialize(ByteBuffer buffer, short nodeType) {
   public static PlanNode deserializeWithTemplate(ByteBuffer buffer, TypeProvider typeProvider) {
     short nodeType = buffer.getShort();
     switch (nodeType) {
+      case 1:
+        return DeviceViewNode.deserializeUseTemplate(buffer, typeProvider);
       case 3:
         return FilterNode.deserializeUseTemplate(buffer, typeProvider);
+      case 32:
+        return ProjectNode.deserializeUseTemplate(buffer, typeProvider);
       case 33:
         return AlignedSeriesScanNode.deserializeUseTemplate(buffer, typeProvider);
       case 34:
         return AlignedSeriesAggregationScanNode.deserializeUseTemplate(buffer, typeProvider);
       case 65:
         return SingleDeviceViewNode.deserializeUseTemplate(buffer, typeProvider);
-      case 32:
-        return ProjectNode.deserializeUseTemplate(buffer, typeProvider);
       default:
         return deserialize(buffer, nodeType);
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java
index b1f18c555a60..dcb29879365b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java
@@ -18,6 +18,7 @@
  */
 package org.apache.iotdb.db.queryengine.plan.planner.plan.node.process;
 
+import org.apache.iotdb.db.queryengine.plan.analyze.TypeProvider;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeId;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeType;
@@ -175,18 +176,21 @@ protected void serializeAttributes(DataOutputStream stream) throws IOException {
 
   public static DeviceViewNode deserialize(ByteBuffer byteBuffer) {
     OrderByParameter mergeOrderParameter = OrderByParameter.deserialize(byteBuffer);
+
     int columnSize = ReadWriteIOUtils.readInt(byteBuffer);
     List<String> outputColumnNames = new ArrayList<>();
     while (columnSize > 0) {
       outputColumnNames.add(ReadWriteIOUtils.readString(byteBuffer));
       columnSize--;
     }
+
     int devicesSize = ReadWriteIOUtils.readInt(byteBuffer);
     List<String> devices = new ArrayList<>();
     while (devicesSize > 0) {
       devices.add(ReadWriteIOUtils.readString(byteBuffer));
       devicesSize--;
     }
+
     int mapSize = ReadWriteIOUtils.readInt(byteBuffer);
     Map<String, List<Integer>> deviceToMeasurementIndexesMap = new HashMap<>(mapSize);
     while (mapSize > 0) {
@@ -205,6 +209,49 @@ public static DeviceViewNode deserialize(ByteBuffer byteBuffer) {
         planNodeId, mergeOrderParameter, outputColumnNames, devices, deviceToMeasurementIndexesMap);
   }
 
+  @Override
+  public void serializeUseTemplate(DataOutputStream stream, TypeProvider typeProvider)
+      throws IOException {
+    PlanNodeType.DEVICE_VIEW.serialize(stream);
+    id.serialize(stream);
+    mergeOrderParameter.serializeAttributes(stream);
+    ReadWriteIOUtils.write(devices.size(), stream);
+    for (String deviceName : devices) {
+      ReadWriteIOUtils.write(deviceName, stream);
+    }
+
+    ReadWriteIOUtils.write(getChildren().size(), stream);
+    for (PlanNode planNode : getChildren()) {
+      planNode.serializeUseTemplate(stream, typeProvider);
+    }
+  }
+
+  public static DeviceViewNode deserializeUseTemplate(
+      ByteBuffer byteBuffer, TypeProvider typeProvider) {
+    PlanNodeId planNodeId = PlanNodeId.deserialize(byteBuffer);
+    OrderByParameter mergeOrderParameter = OrderByParameter.deserialize(byteBuffer);
+
+    int devicesSize = ReadWriteIOUtils.readInt(byteBuffer);
+    List<String> devices = new ArrayList<>(devicesSize);
+    while (devicesSize > 0) {
+      devices.add(ReadWriteIOUtils.readString(byteBuffer));
+      devicesSize--;
+    }
+
+    Map<String, List<Integer>> deviceToMeasurementIndexesMap = new HashMap<>(devices.size());
+    for (String deviceName : devices) {
+      deviceToMeasurementIndexesMap.put(
+          deviceName, typeProvider.getTemplatedInfo().getDeviceToMeasurementIndexes());
+    }
+
+    return new DeviceViewNode(
+        planNodeId,
+        mergeOrderParameter,
+        typeProvider.getTemplatedInfo().getDeviceViewOutputNames(),
+        devices,
+        deviceToMeasurementIndexesMap);
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/RawDataAggregationNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/RawDataAggregationNode.java
index 345d29770885..dafcbdb9409f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/RawDataAggregationNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/RawDataAggregationNode.java
@@ -124,6 +124,26 @@ public RawDataAggregationNode(
     this.outputEndTime = outputEndTime;
   }
 
+  // to avoid the repeated invoking of getDeduplicatedDescriptors method
+  public RawDataAggregationNode(
+      PlanNodeId id,
+      PlanNode child,
+      List<AggregationDescriptor> deduplicatedAggregationDescriptorList,
+      @Nullable GroupByTimeParameter groupByTimeParameter,
+      @Nullable GroupByParameter groupByParameter,
+      Expression groupByExpression,
+      boolean outputEndTime,
+      Ordering scanOrder,
+      boolean useDeduplicatedDescriptors) {
+    super(id, child);
+    this.aggregationDescriptorList = deduplicatedAggregationDescriptorList;
+    this.scanOrder = scanOrder;
+    this.groupByParameter = groupByParameter;
+    this.groupByTimeParameter = groupByTimeParameter;
+    this.groupByExpression = groupByExpression;
+    this.outputEndTime = outputEndTime;
+  }
+
   public List<AggregationDescriptor> getAggregationDescriptorList() {
     return aggregationDescriptorList;
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
index 7bdbea3a577a..5ed66c5c3724 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
@@ -291,7 +291,7 @@ public static AlignedSeriesAggregationScanNode deserializeUseTemplate(
         typeProvider.getTemplatedInfo().getScanOrder(),
         typeProvider.getTemplatedInfo().outputEndTime,
         typeProvider.getTemplatedInfo().getPushDownPredicate(),
-        typeProvider.getTemplatedInfo().groupByTimeParameter,
+        typeProvider.getTemplatedInfo().groupByTimeParameter.clone(),
         null);
   }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/GroupByTimeParameter.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/GroupByTimeParameter.java
index 9de54f85c0a1..d4b979f91a85 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/GroupByTimeParameter.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/GroupByTimeParameter.java
@@ -162,4 +162,8 @@ public boolean equals(Object obj) {
   public int hashCode() {
     return Objects.hash(startTime, endTime, interval, slidingStep, leftCRightO);
   }
+
+  public GroupByTimeParameter clone() {
+    return new GroupByTimeParameter(startTime, endTime, interval, slidingStep, leftCRightO);
+  }
 }

From bd76f673d965cea98ce777068d9cfb88fd935885 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Wed, 15 May 2024 09:05:53 +0800
Subject: [PATCH 16/28] fix
 typeProvider.getTemplatedInfo().groupByTimeParameter problem

---
 .../plan/node/source/AlignedSeriesAggregationScanNode.java      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
index 5ed66c5c3724..7bdbea3a577a 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
@@ -291,7 +291,7 @@ public static AlignedSeriesAggregationScanNode deserializeUseTemplate(
         typeProvider.getTemplatedInfo().getScanOrder(),
         typeProvider.getTemplatedInfo().outputEndTime,
         typeProvider.getTemplatedInfo().getPushDownPredicate(),
-        typeProvider.getTemplatedInfo().groupByTimeParameter.clone(),
+        typeProvider.getTemplatedInfo().groupByTimeParameter,
         null);
   }
 

From 7d8f8f8020c47017c8af23f7dd84b418f88a9452 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Wed, 15 May 2024 15:47:15 +0800
Subject: [PATCH 17/28] add IoTDBAlignByDeviceWithTemplateAggregationIT

---
 ...lignByDeviceWithTemplateAggregationIT.java | 142 ++++++++++++++++++
 1 file changed, 142 insertions(+)
 create mode 100644 integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java

diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
new file mode 100644
index 000000000000..4a7bb62d5179
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
@@ -0,0 +1,142 @@
+/*
+ * 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.iotdb.db.it.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.ClusterIT;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.Statement;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.resultSetEqualTest;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class, ClusterIT.class})
+public class IoTDBAlignByDeviceWithTemplateAggregationIT {
+  private static final String[] sqls =
+      new String[] {
+        // non-aligned template
+        "CREATE database root.sg1;",
+        "CREATE schema template t1 (s1 FLOAT encoding=RLE, s2 BOOLEAN encoding=PLAIN compression=SNAPPY, s3 INT32);",
+        "SET SCHEMA TEMPLATE t1 to root.sg1;",
+        "INSERT INTO root.sg1.d1(timestamp,s1,s2,s3) values(1,1.1,false,1), (2,2.2,false,2), (5,5.5,true,5), (1314000000000,13.14,true,1314);",
+        "INSERT INTO root.sg1.d2(timestamp,s1,s2,s3) values(1,11.1,false,11), (2,22.2,false,22), (5,50.0,false,5), (1314000000001,13.15,false,1315);",
+        "flush;",
+        "INSERT INTO root.sg1.d3(timestamp,s1,s2,s3) values(1,111.1,true,null), (4,444.4,true,44), (8,8.8,false,4), (1314000000002,13.16,false,1316);",
+        "INSERT INTO root.sg1.d4(timestamp,s1,s2,s3) values(1,1111.1,true,1111), (5,5555.5,false,5555), (8,0.8,true,10), (1314000000003,13.14,true,1314);",
+
+        // aligned template
+        "CREATE database root.sg2;",
+        "CREATE schema template t2 aligned (s1 FLOAT encoding=RLE, s2 BOOLEAN encoding=PLAIN compression=SNAPPY, s3 INT32);",
+        "SET SCHEMA TEMPLATE t2 to root.sg2;",
+        "INSERT INTO root.sg2.d1(timestamp,s1,s2,s3) values(1,1.1,false,1), (2,2.2,false,2), (5,5.5,true,5), (1314000000000,13.14,true,1314);",
+        "INSERT INTO root.sg2.d2(timestamp,s1,s2,s3) values(1,11.1,false,11), (2,22.2,false,22), (5,50.0,false,5), (1314000000001,13.15,false,1315);",
+        "flush;",
+        "INSERT INTO root.sg2.d3(timestamp,s1,s2,s3) values(1,111.1,true,null), (4,444.4,true,44), (8,8.8,false,4), (1314000000002,13.16,false,1316);",
+        "INSERT INTO root.sg2.d4(timestamp,s1,s2,s3) values(1,1111.1,true,1111), (5,5555.5,false,5555), (8,0.8,true,10), (1314000000003,13.14,true,1314);",
+      };
+
+  @BeforeClass
+  public static void setUp() throws Exception {
+    EnvFactory.getEnv().initClusterEnvironment();
+    insertData();
+  }
+
+  @AfterClass
+  public static void tearDown() throws Exception {
+    EnvFactory.getEnv().cleanClusterEnvironment();
+  }
+
+  @Test
+  public void aggregationTest() {
+    // only descending test
+    // no value filter
+    String[] expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),last_value(s2)"};
+    String[] retArray =
+        new String[] {
+          "root.sg2.d1,1314000000000,13.14,true,",
+          "root.sg2.d2,1314000000001,13.15,false,",
+          "root.sg2.d3,1314000000002,13.16,false,",
+          "root.sg2.d4,1314000000003,13.14,true,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** align by device;",
+        expectedHeader,
+        retArray);
+
+    // value filter + having
+    retArray =
+        new String[] {
+          "root.sg2.d2,1314000000001,13.15,false,",
+          "root.sg2.d3,1314000000002,13.16,false,",
+          "root.sg2.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+
+    // value filter + having + group by time
+    expectedHeader = new String[] {"Time,Device,max_time(s1),last_value(s1),last_value(s2)"};
+    retArray =
+        new String[] {
+          "1,root.sg2.d1,2,2.2,false,",
+          "1,root.sg2.d2,2,22.2,false,",
+          "5,root.sg2.d2,5,50.0,false,",
+          "7,root.sg2.d3,8,8.8,false,",
+          "5,root.sg2.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s3+1=1316 or s2=false group by ([1,10),2ms) having avg(s1)>0 align by device;",
+        expectedHeader,
+        retArray);
+
+    // agg operation expression
+
+    // group by session,
+
+    // order by
+
+    // wildcald
+
+    // ascending with descending
+
+    // count_time
+  }
+
+  protected static void insertData() {
+    try (Connection connection = EnvFactory.getEnv().getConnection();
+        Statement statement = connection.createStatement()) {
+
+      for (String sql : sqls) {
+        statement.execute(sql);
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+}

From 8854da15f36c6436dedd97bb08cb0e2e33824bbf Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Thu, 16 May 2024 21:39:08 +0800
Subject: [PATCH 18/28] support sliding window, fix visitSlidingWindow method
 of OperatorGeneratorTree; support order by time;  add schemaMap for
 templateInfo; fix devicePath of SingleDeviceViewNode.

---
 ...lignByDeviceWithTemplateAggregationIT.java |  86 ++++++++++++--
 .../analyze/TemplatedAggregationAnalyze.java  |  12 +-
 .../plan/analyze/TemplatedAnalyze.java        |   2 +-
 .../plan/analyze/TemplatedInfo.java           |  56 ++++++---
 .../optimization/AggregationPushDown.java     |   1 +
 .../plan/planner/LogicalPlanBuilder.java      |   3 -
 .../plan/planner/OperatorTreeGenerator.java   |  37 ++++--
 .../plan/planner/TemplatedLogicalPlan.java    | 109 ++++++++----------
 .../planner/TemplatedLogicalPlanBuilder.java  |  22 +++-
 .../AlignedSeriesAggregationScanNode.java     |   6 +-
 .../plan/parameter/GroupByTimeParameter.java  |   4 -
 11 files changed, 213 insertions(+), 125 deletions(-)

diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
index 4a7bb62d5179..084f35ee2559 100644
--- a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
@@ -32,6 +32,7 @@
 import java.sql.Connection;
 import java.sql.Statement;
 
+import static org.apache.iotdb.db.it.utils.TestUtils.assertTestFail;
 import static org.apache.iotdb.db.it.utils.TestUtils.resultSetEqualTest;
 
 @RunWith(IoTDBTestRunner.class)
@@ -100,32 +101,95 @@ public void aggregationTest() {
         expectedHeader,
         retArray);
 
-    // value filter + having + group by time
+    // ascending with descending
+
+    // group by session, condition,
+
+    // wildcard: agg(*)
+
+    // count_time(*)
+
+    // agg operation expression : agg(s1+1)
+
+    // duplicate select expressions
+
+    // non aligned template: sg1
+
+    // filter cannot push down
+
+    // having count(s1+s2)
+  }
+
+  @Test
+  public void groupByTest() {
+    //
+    String[] expectedHeader =
+        new String[] {"Time,Device,max_time(s1),last_value(s1),last_value(s2)"};
+    String[] retArray =
+        new String[] {
+          "1,root.sg2.d1,2,2.2,false,",
+          "5,root.sg2.d1,5,5.5,true,",
+          "1,root.sg2.d2,2,22.2,false,",
+          "5,root.sg2.d2,5,50.0,false,",
+          "1,root.sg2.d3,1,111.1,true,",
+        };
+    resultSetEqualTest(
+        "select max_time(s1), last_value(s1), last_value(s2) from root.sg2.** group by ([1,10), 2ms) having last_value(s2) is not null limit 5 align by device;",
+        expectedHeader,
+        retArray);
+
+    // sliding window
     expectedHeader = new String[] {"Time,Device,max_time(s1),last_value(s1),last_value(s2)"};
     retArray =
         new String[] {
           "1,root.sg2.d1,2,2.2,false,",
           "1,root.sg2.d2,2,22.2,false,",
+          "3,root.sg2.d2,5,50.0,false,",
           "5,root.sg2.d2,5,50.0,false,",
           "7,root.sg2.d3,8,8.8,false,",
+          "3,root.sg2.d4,5,5555.5,false,",
           "5,root.sg2.d4,5,5555.5,false,",
         };
     resultSetEqualTest(
-        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s3+1=1316 or s2=false group by ([1,10),2ms) having avg(s1)>0 align by device;",
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s3+1=1316 or s2=false group by ([1,10),3ms,2ms) having avg(s1)>0 align by device;",
         expectedHeader,
         retArray);
+  }
 
-    // agg operation expression
-
-    // group by session,
-
-    // order by
-
-    // wildcald
+  @Test
+  public void orderByTest() {
+    String[] expectedHeader = new String[] {"Time,Device,sum(s3)"};
+    String[] retArray =
+        new String[] {
+          "4,root.sg2.d1,5.0,",
+          "4,root.sg2.d2,5.0,",
+          "4,root.sg2.d3,44.0,",
+          "4,root.sg2.d4,5555.0,",
+          "2,root.sg2.d1,2.0,",
+        };
+    resultSetEqualTest(
+        "select sum(s3) from root.sg2.** where s1>1 GROUP BY([0, 10), 2ms) order by time desc offset 8 limit 5 align by device;",
+        expectedHeader,
+        retArray);
 
-    // ascending with descending
+    expectedHeader = new String[] {"Time,Device,sum(s3)"};
+    retArray =
+        new String[] {
+          "0,root.sg2.d1,1.0,",
+          "2,root.sg2.d1,2.0,",
+          "4,root.sg2.d1,5.0,",
+          "0,root.sg2.d2,11.0,",
+          "2,root.sg2.d2,22.0,",
+        };
+    resultSetEqualTest(
+        "select sum(s3) from root.sg2.** where s1>1 GROUP BY([0, 10), 2ms) order by count(s2) desc limit 5 align by device;",
+        expectedHeader,
+        retArray);
 
-    // count_time
+    // order by non-existent measurement
+    assertTestFail(
+        "select sum(s3) from root.sg2.** where s1>1 order by count(s_null) desc limit 5 align by device;",
+        "count(s_null) in order by clause doesn't exist.");
   }
 
   protected static void insertData() {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index cf19a791482f..dc926303880a 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -64,6 +64,10 @@ static boolean canBuildAggregationPlanUseTemplate(
       MPPQueryContext context,
       Template template) {
 
+    if (queryStatement.hasOrderByExpression()) {
+      return false;
+    }
+
     analysis.setNoWhereAndAggregation(false);
 
     List<PartialPath> deviceList = analyzeFrom(queryStatement, schemaTree);
@@ -93,7 +97,7 @@ static boolean canBuildAggregationPlanUseTemplate(
       return true;
     }
 
-    analyzeHaving(analysis, queryStatement, schemaTree, deviceList);
+    analyzeHaving(analysis, queryStatement);
 
     analyzeDeviceToAggregation(analysis);
     analyzeDeviceToSourceTransform(analysis);
@@ -177,11 +181,7 @@ private static boolean analyzeSelect(
     return true;
   }
 
-  private static void analyzeHaving(
-      Analysis analysis,
-      QueryStatement queryStatement,
-      ISchemaTree schemaTree,
-      List<PartialPath> deviceSet) {
+  private static void analyzeHaving(Analysis analysis, QueryStatement queryStatement) {
     if (!queryStatement.hasHaving()) {
       return;
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
index bc14b2c55cdf..1c56f3c4ba26 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
@@ -270,7 +270,7 @@ static void analyzeDeviceToWhere(Analysis analysis, QueryStatement queryStatemen
     }
   }
 
-  private static void analyzeDeviceToOrderBy(
+  static void analyzeDeviceToOrderBy(
       Analysis analysis,
       QueryStatement queryStatement,
       ISchemaTree schemaTree,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
index 2ae63c12a90f..d9981a97a91c 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
@@ -77,15 +77,12 @@ public class TemplatedInfo {
   private int maxTsBlockLineNum = -1;
 
   // variables related to predicate push down
-  // TODO when to init pushDownPredicate in agg situation?
   private Expression pushDownPredicate;
 
   // variables related to aggregation
-  public List<AggregationDescriptor> aggregationDescriptorList;
-  public GroupByTimeParameter groupByTimeParameter;
-  public boolean outputEndTime;
-
-  private Expression havingExpression;
+  private List<AggregationDescriptor> aggregationDescriptorList;
+  private final GroupByTimeParameter groupByTimeParameter;
+  private final boolean outputEndTime;
 
   public TemplatedInfo(
       List<String> measurementList,
@@ -117,11 +114,11 @@ public TemplatedInfo(
     this.predicate = predicate;
     if (predicate != null) {
       this.keepNull = keepNull;
-      this.schemaMap = schemaMap;
       this.filterLayoutMap = filterLayoutMap;
     }
     this.pushDownPredicate = pushDownPredicate;
 
+    this.schemaMap = schemaMap;
     this.aggregationDescriptorList = aggregationDescriptorList;
     this.groupByTimeParameter = groupByTimeParameter;
     this.outputEndTime = outputEndTime;
@@ -202,6 +199,22 @@ public Expression[] getProjectExpressions() {
     return projectExpressions;
   }
 
+  public void setAggregationDescriptorList(List<AggregationDescriptor> aggregationDescriptorList) {
+    this.aggregationDescriptorList = aggregationDescriptorList;
+  }
+
+  public List<AggregationDescriptor> getAggregationDescriptorList() {
+    return this.aggregationDescriptorList;
+  }
+
+  public GroupByTimeParameter getGroupByTimeParameter() {
+    return this.groupByTimeParameter;
+  }
+
+  public boolean isOutputEndTime() {
+    return outputEndTime;
+  }
+
   public static Map<String, List<InputLocation>> makeLayout(List<String> measurementList) {
     Map<String, List<InputLocation>> outputMappings = new LinkedHashMap<>();
     int tsBlockIndex = 0;
@@ -273,6 +286,8 @@ public void serialize(ByteBuffer byteBuffer) {
     } else {
       ReadWriteIOUtils.write((byte) 0, byteBuffer);
     }
+
+    ReadWriteIOUtils.write(outputEndTime, byteBuffer);
   }
 
   public void serialize(DataOutputStream stream) throws IOException {
@@ -332,6 +347,8 @@ public void serialize(DataOutputStream stream) throws IOException {
     } else {
       ReadWriteIOUtils.write((byte) 0, stream);
     }
+
+    ReadWriteIOUtils.write(outputEndTime, stream);
   }
 
   public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
@@ -377,20 +394,21 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
     long limitValue = ReadWriteIOUtils.readLong(byteBuffer);
 
     Expression predicate = null;
-    byte hasFilter = ReadWriteIOUtils.readByte(byteBuffer);
-    Map<String, IMeasurementSchema> currentSchemaMap = null;
-    Map<String, List<InputLocation>> layoutMap = null;
     boolean keepNull = false;
+    Map<String, List<InputLocation>> filterLayoutMap = null;
+    byte hasFilter = ReadWriteIOUtils.readByte(byteBuffer);
     if (hasFilter == 1) {
       predicate = Expression.deserialize(byteBuffer);
       keepNull = ReadWriteIOUtils.readBool(byteBuffer);
-      currentSchemaMap = new HashMap<>();
-      for (IMeasurementSchema measurementSchema : measurementSchemaList) {
-        currentSchemaMap.put(measurementSchema.getMeasurementId(), measurementSchema);
-      }
-      layoutMap = makeLayout(measurementList);
+      filterLayoutMap = makeLayout(measurementList);
     }
 
+    Map<String, IMeasurementSchema> measurementSchemaMap =
+        new HashMap<>(measurementSchemaList.size());
+    measurementSchemaList.forEach(
+        measurementSchema ->
+            measurementSchemaMap.put(measurementSchema.getMeasurementId(), measurementSchema));
+
     Expression pushDownPredicate = null;
     byte hasPushDownFilter = ReadWriteIOUtils.readByte(byteBuffer);
     if (hasPushDownFilter == 1) {
@@ -412,7 +430,7 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
       groupByTimeParameter = GroupByTimeParameter.deserialize(byteBuffer);
     }
 
-    // TODO add outputEndTime serialization and deserialization
+    boolean outputEndTime = ReadWriteIOUtils.readBool(byteBuffer);
 
     return new TemplatedInfo(
         measurementList,
@@ -426,11 +444,11 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
         limitValue,
         predicate,
         keepNull,
-        currentSchemaMap,
-        layoutMap,
+        measurementSchemaMap,
+        filterLayoutMap,
         pushDownPredicate,
         aggregationDescriptorList,
         groupByTimeParameter,
-        false);
+        outputEndTime);
   }
 }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index 2e65e7501937..1df1279903d0 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -194,6 +194,7 @@ public PlanNode visitDeviceView(DeviceViewNode node, RewriterContext context) {
     @Override
     public PlanNode visitSingleDeviceView(SingleDeviceViewNode node, RewriterContext context) {
       context.setCurDevice(node.getDevice());
+      context.setCurDevicePath(new PartialPath(node.getDevice().split(",")));
       PlanNode rewrittenChild = node.getChild().accept(this, context);
       node.setChild(rewrittenChild);
       return node;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
index b696501a4174..f1beddaaf456 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
@@ -736,9 +736,6 @@ public LogicalPlanBuilder planSlidingWindowAggregation(
       GroupByTimeParameter groupByTimeParameter,
       AggregationStep curStep,
       Ordering scanOrder) {
-    if (aggregationExpressions == null) {
-      return this;
-    }
 
     this.root =
         createSlidingWindowAggregationNode(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
index 6b2ecccfd65a..0e48759983c4 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
@@ -494,7 +494,7 @@ public Operator visitProject(ProjectNode node, LocalExecutionPlanContext context
     List<String> inputColumnNames;
     List<String> outputColumnNames = node.getOutputColumnNames();
     if (outputColumnNames == null) {
-      if (context.getTypeProvider().getTemplatedInfo().aggregationDescriptorList != null) {
+      if (context.getTypeProvider().getTemplatedInfo().getAggregationDescriptorList() != null) {
         // TODO fix it
         // outputColumnNames is aggregation expression
         outputColumnNames = context.getTypeProvider().getTemplatedInfo().getDeviceViewOutputNames();
@@ -600,14 +600,15 @@ public Operator visitSeriesAggregationScan(
   public Operator visitAlignedSeriesAggregationScan(
       AlignedSeriesAggregationScanNode node, LocalExecutionPlanContext context) {
     if (context.isBuildPlanUseTemplate()) {
+      // TODO template situation, variables such as aggregator, scanOptions may be serialized once
       return constructAlignedSeriesAggregationScanOperator(
           node.getPlanNodeId(),
           node.getAlignedPath(),
-          context.getTemplatedInfo().aggregationDescriptorList,
+          context.getTemplatedInfo().getAggregationDescriptorList(),
           context.getTemplatedInfo().getPushDownPredicate(),
           context.getTemplatedInfo().getScanOrder(),
-          context.getTemplatedInfo().groupByTimeParameter,
-          context.getTemplatedInfo().outputEndTime,
+          context.getTemplatedInfo().getGroupByTimeParameter(),
+          context.getTemplatedInfo().isOutputEndTime(),
           context);
     }
 
@@ -640,7 +641,6 @@ private Operator constructAlignedSeriesAggregationScanOperator(
 
       Expression expression = descriptor.getInputExpressions().get(0);
       if (expression instanceof TimeSeriesOperand) {
-        // TODO for template_agg, no need use getPath.getMeasurement
         String inputSeries =
             ((TimeSeriesOperand) (descriptor.getInputExpressions().get(0)))
                 .getPath()
@@ -654,7 +654,6 @@ private Operator constructAlignedSeriesAggregationScanOperator(
                     descriptor.getAggregationFuncName(),
                     descriptor.getAggregationType(),
                     Collections.singletonList(seriesDataType),
-                    // TODO inputExpression must be devicePath+measurement
                     descriptor.getInputExpressions(),
                     descriptor.getInputAttributes(),
                     ascending,
@@ -669,7 +668,6 @@ private Operator constructAlignedSeriesAggregationScanOperator(
                     descriptor.getAggregationFuncName(),
                     descriptor.getAggregationType(),
                     Collections.singletonList(TSDataType.INT64),
-                    // TODO inputExpression must be devicePath+measurement
                     descriptor.getInputExpressions(),
                     descriptor.getInputAttributes(),
                     ascending,
@@ -698,7 +696,6 @@ private Operator constructAlignedSeriesAggregationScanOperator(
           convertPredicateToFilter(
               pushDownPredicate,
               alignedPath.getMeasurementList(),
-              // TODO what's the meaning of isBuildPlanUseTemplate
               context.getTypeProvider().getTemplatedInfo() != null,
               context.getTypeProvider()));
     }
@@ -1364,7 +1361,12 @@ public Operator visitTransform(TransformNode node, LocalExecutionPlanContext con
     final Map<NodeRef<Expression>, TSDataType> expressionTypes = new HashMap<>();
 
     for (Expression projectExpression : projectExpressions) {
-      ExpressionTypeAnalyzer.analyzeExpression(expressionTypes, projectExpression);
+      if (context.isBuildPlanUseTemplate()) {
+        ExpressionTypeAnalyzer.analyzeExpressionUsingTemplatedInfo(
+            expressionTypes, projectExpression, context.getTemplatedInfo());
+      } else {
+        ExpressionTypeAnalyzer.analyzeExpression(expressionTypes, projectExpression);
+      }
     }
 
     boolean hasNonMappableUDF = false;
@@ -1764,13 +1766,24 @@ public Operator visitSlidingWindowAggregation(
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
     for (AggregationDescriptor descriptor : aggregationDescriptors) {
       List<InputLocation[]> inputLocationList = calcInputLocationList(descriptor, layout);
+      List<TSDataType> dataTypes = new ArrayList<>();
+      for (Expression expression : descriptor.getInputExpressions()) {
+        if (context.isBuildPlanUseTemplate() && expression instanceof TimeSeriesOperand) {
+          dataTypes.add(
+              context
+                  .getTemplatedInfo()
+                  .getSchemaMap()
+                  .get(expression.getExpressionString())
+                  .getType());
+        } else {
+          dataTypes.add(context.getTypeProvider().getType(expression.getExpressionString()));
+        }
+      }
       aggregators.add(
           SlidingWindowAggregatorFactory.createSlidingWindowAggregator(
               descriptor.getAggregationFuncName(),
               descriptor.getAggregationType(),
-              descriptor.getInputExpressions().stream()
-                  .map(x -> context.getTypeProvider().getType(x.getExpressionString()))
-                  .collect(Collectors.toList()),
+              dataTypes,
               descriptor.getInputExpressions(),
               descriptor.getInputAttributes(),
               ascending,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
index a00aee711d70..73b29b76f7f6 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
@@ -298,19 +298,10 @@ public PlanNode visitQueryBody(PartialPath devicePath) {
   // ============== Methods below are used for templated aggregation ======================
 
   private PlanNode visitAggregation() {
+    // group by level and group by tag is not allowed in align by device
     boolean outputPartial =
-        queryStatement.isGroupByLevel()
-            || queryStatement.isGroupByTag()
-            || (queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap());
+        queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap();
     AggregationStep curStep = outputPartial ? AggregationStep.PARTIAL : AggregationStep.SINGLE;
-
-    if (queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap()) {
-      curStep =
-          (queryStatement.isGroupByLevel() || queryStatement.isGroupByTag())
-              ? AggregationStep.INTERMEDIATE
-              : AggregationStep.FINAL;
-    }
-
     aggregationDescriptorList =
         constructAggregationDescriptorList(analysis.getAggregationExpressions(), curStep);
     updateTypeProvider(analysis.getAggregationExpressions());
@@ -321,13 +312,14 @@ private PlanNode visitAggregation() {
                   aggregationDescriptor, context.getTypeProvider()));
     }
 
-    context.getTypeProvider().getTemplatedInfo().aggregationDescriptorList =
-        aggregationDescriptorList;
-
-    LogicalPlanBuilder planBuilder =
+    LogicalPlanBuilder templatedPlanBuilder =
         new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList);
     Map<String, PlanNode> deviceToSubPlanMap = new LinkedHashMap<>();
-    deduplicatedDescriptors = getDeduplicatedDescriptors(aggregationDescriptorList);
+    aggregationDescriptorList = getDeduplicatedDescriptors(aggregationDescriptorList);
+    context
+        .getTypeProvider()
+        .getTemplatedInfo()
+        .setAggregationDescriptorList(aggregationDescriptorList);
     for (PartialPath devicePath : analysis.getDeviceList()) {
       String deviceName = devicePath.getFullPath();
       PlanNode rootNode = visitDeviceAggregationBody(devicePath, curStep);
@@ -339,46 +331,44 @@ private PlanNode visitAggregation() {
       deviceToSubPlanMap.put(deviceName, subPlanBuilder.getRoot());
     }
 
-    // convert to ALIGN BY DEVICE view
-    planBuilder =
-        planBuilder.planDeviceView(
-            deviceToSubPlanMap,
-            analysis.getDeviceViewOutputExpressions(),
-            analysis.getDeviceViewInputIndexesMap(),
-            analysis.getSelectExpressions(),
-            queryStatement,
-            analysis);
-
-    planBuilder =
-        planBuilder.planHavingAndTransform(
-            analysis.getHavingExpression(),
-            analysis.getSelectExpressions(),
-            analysis.getOrderByExpressions(),
-            queryStatement.isGroupByTime(),
-            queryStatement.getResultTimeOrder());
+    templatedPlanBuilder =
+        templatedPlanBuilder
+            .planDeviceView(
+                deviceToSubPlanMap,
+                analysis.getDeviceViewOutputExpressions(),
+                analysis.getDeviceViewInputIndexesMap(),
+                analysis.getSelectExpressions(),
+                queryStatement,
+                analysis)
+            .planHavingAndTransform(
+                analysis.getHavingExpression(),
+                analysis.getSelectExpressions(),
+                analysis.getOrderByExpressions(),
+                queryStatement.isGroupByTime(),
+                queryStatement.getResultTimeOrder());
 
     if (!queryStatement.needPushDownSort()) {
-      planBuilder = planBuilder.planOrderBy(queryStatement, analysis);
+      templatedPlanBuilder = templatedPlanBuilder.planOrderBy(queryStatement, analysis);
     }
 
-    planBuilder =
-        planBuilder
+    templatedPlanBuilder =
+        templatedPlanBuilder
             .planFill(analysis.getFillDescriptor(), queryStatement.getResultTimeOrder())
             .planOffset(queryStatement.getRowOffset());
 
     if (!analysis.isUseTopKNode() || queryStatement.hasOffset()) {
-      planBuilder = planBuilder.planLimit(queryStatement.getRowLimit());
+      templatedPlanBuilder = templatedPlanBuilder.planLimit(queryStatement.getRowLimit());
     }
 
-    return planBuilder.getRoot();
+    return templatedPlanBuilder.getRoot();
   }
 
   private PlanNode visitDeviceAggregationBody(PartialPath devicePath, AggregationStep curStep) {
-    TemplatedLogicalPlanBuilder planBuilder =
+    TemplatedLogicalPlanBuilder templatedPlanBuilder =
         new TemplatedLogicalPlanBuilder(analysis, context, newMeasurementList, newSchemaList);
 
-    planBuilder =
-        planBuilder
+    templatedPlanBuilder =
+        templatedPlanBuilder
             .planRawDataSource(
                 devicePath,
                 queryStatement.getResultTimeOrder(),
@@ -388,30 +378,23 @@ private PlanNode visitDeviceAggregationBody(PartialPath devicePath, AggregationS
             .planFilter(
                 whereExpression,
                 queryStatement.isGroupByTime(),
+                queryStatement.getResultTimeOrder())
+            .planRawDataAggregation(
+                analysis.getAggregationExpressions(),
+                null,
+                analysis.getGroupByTimeParameter(),
+                analysis.getGroupByParameter(),
+                queryStatement.isOutputEndTime(),
+                curStep,
+                queryStatement.getResultTimeOrder(),
+                aggregationDescriptorList)
+            .planSlidingWindowAggregation(
+                queryStatement,
+                analysis.getAggregationExpressions(),
+                analysis.getGroupByTimeParameter(),
                 queryStatement.getResultTimeOrder());
 
-    planBuilder =
-        planBuilder.planRawDataAggregation(
-            analysis.getAggregationExpressions(),
-            null,
-            analysis.getGroupByTimeParameter(),
-            analysis.getGroupByParameter(),
-            queryStatement.isOutputEndTime(),
-            curStep,
-            queryStatement.getResultTimeOrder(),
-            deduplicatedDescriptors);
-
-    if (queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap()) {
-      planBuilder =
-          planBuilder.planSlidingWindowAggregation(
-              analysis.getSelectExpressions(),
-              analysis.getGroupByTimeParameter(),
-              curStep,
-              queryStatement.getResultTimeOrder());
-    }
-
-    // no group by level and group by tag
-    return planBuilder.getRoot();
+    return templatedPlanBuilder.getRoot();
   }
 
   private List<AggregationDescriptor> constructAggregationDescriptorList(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
index 3ee79317753c..1d8350ba0075 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
@@ -35,13 +35,17 @@
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.GroupByParameter;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.GroupByTimeParameter;
 import org.apache.iotdb.db.queryengine.plan.statement.component.Ordering;
+import org.apache.iotdb.db.queryengine.plan.statement.crud.QueryStatement;
 
 import org.apache.tsfile.write.schema.IMeasurementSchema;
 
 import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 
+import static org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant.DEVICE;
+
 /**
  * This class provides accelerated implementation for multiple devices align by device query. This
  * optimization is only used for devices set in only one template, using template can avoid many
@@ -167,17 +171,29 @@ public TemplatedLogicalPlanBuilder planRawDataAggregation(
   }
 
   public TemplatedLogicalPlanBuilder planSlidingWindowAggregation(
+      QueryStatement queryStatement,
       Set<Expression> aggregationExpressions,
       GroupByTimeParameter groupByTimeParameter,
-      AggregationStep curStep,
       Ordering scanOrder) {
-    if (aggregationExpressions == null) {
+    if (!queryStatement.isGroupByTime() || !analysis.getGroupByTimeParameter().hasOverlap()) {
       return this;
     }
 
+    LinkedHashSet<Expression> slidingWindowsExpressions = new LinkedHashSet<>();
+    aggregationExpressions.forEach(
+        expression -> {
+          if (!DEVICE.equalsIgnoreCase(expression.getOutputSymbol())) {
+            slidingWindowsExpressions.add(expression);
+          }
+        });
     this.root =
         createSlidingWindowAggregationNode(
-            this.getRoot(), aggregationExpressions, groupByTimeParameter, curStep, scanOrder);
+            this.getRoot(),
+            slidingWindowsExpressions,
+            groupByTimeParameter,
+            AggregationStep.FINAL,
+            scanOrder);
+
     return this;
   }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
index 7bdbea3a577a..adaad506184c 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
@@ -287,11 +287,11 @@ public static AlignedSeriesAggregationScanNode deserializeUseTemplate(
     return new AlignedSeriesAggregationScanNode(
         planNodeId,
         alignedPath,
-        typeProvider.getTemplatedInfo().aggregationDescriptorList,
+        typeProvider.getTemplatedInfo().getAggregationDescriptorList(),
         typeProvider.getTemplatedInfo().getScanOrder(),
-        typeProvider.getTemplatedInfo().outputEndTime,
+        typeProvider.getTemplatedInfo().isOutputEndTime(),
         typeProvider.getTemplatedInfo().getPushDownPredicate(),
-        typeProvider.getTemplatedInfo().groupByTimeParameter,
+        typeProvider.getTemplatedInfo().getGroupByTimeParameter(),
         null);
   }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/GroupByTimeParameter.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/GroupByTimeParameter.java
index d4b979f91a85..9de54f85c0a1 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/GroupByTimeParameter.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/GroupByTimeParameter.java
@@ -162,8 +162,4 @@ public boolean equals(Object obj) {
   public int hashCode() {
     return Objects.hash(startTime, endTime, interval, slidingStep, leftCRightO);
   }
-
-  public GroupByTimeParameter clone() {
-    return new GroupByTimeParameter(startTime, endTime, interval, slidingStep, leftCRightO);
-  }
 }

From 569d6eddcd5d689e01a183021e1d9a14ba862881 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Fri, 24 May 2024 22:05:50 +0800
Subject: [PATCH 19/28] add ascending and descending aggregation descriptors
 support

---
 ...lignByDeviceWithTemplateAggregationIT.java | 126 +++++++++++++--
 .../analyze/TemplatedAggregationAnalyze.java  |   3 +-
 .../plan/analyze/TemplatedInfo.java           | 143 ++++++++++--------
 .../optimization/AggregationPushDown.java     |  71 ++++-----
 .../plan/planner/OperatorTreeGenerator.java   |  11 +-
 .../plan/planner/TemplatedLogicalPlan.java    |  25 ++-
 .../distribution/DistributionPlanner.java     |   3 +
 .../AlignedSeriesAggregationScanNode.java     |  38 ++++-
 8 files changed, 284 insertions(+), 136 deletions(-)

diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
index 084f35ee2559..eda3b484697b 100644
--- a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
@@ -79,17 +79,41 @@ public void aggregationTest() {
     String[] expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),last_value(s2)"};
     String[] retArray =
         new String[] {
-          "root.sg2.d1,1314000000000,13.14,true,",
-          "root.sg2.d2,1314000000001,13.15,false,",
-          "root.sg2.d3,1314000000002,13.16,false,",
-          "root.sg2.d4,1314000000003,13.14,true,",
+          "root.sg1.d1,1314000000000,13.14,true,",
+          "root.sg1.d2,1314000000001,13.15,false,",
+          "root.sg1.d3,1314000000002,13.16,false,",
+          "root.sg1.d4,1314000000003,13.14,true,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** align by device;",
+        expectedHeader,
+        retArray);
+
+    expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),last_value(s2)"};
+    retArray =
+        new String[] {
+          "root.sg1.d1,1314000000000,13.14,true,",
+          "root.sg1.d2,1314000000001,13.15,false,",
+          "root.sg1.d3,1314000000002,13.16,false,",
+          "root.sg1.d4,1314000000003,13.14,true,",
         };
     resultSetEqualTest(
-        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** align by device;",
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** align by device;",
         expectedHeader,
         retArray);
 
     // value filter + having
+    retArray =
+        new String[] {
+          "root.sg1.d2,1314000000001,13.15,false,",
+          "root.sg1.d3,1314000000002,13.16,false,",
+          "root.sg1.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+
     retArray =
         new String[] {
           "root.sg2.d2,1314000000001,13.15,false,",
@@ -101,20 +125,34 @@ public void aggregationTest() {
         expectedHeader,
         retArray);
 
-    // ascending with descending
-
-    // group by session, condition,
-
-    // wildcard: agg(*)
+    // supported: ascending with descending aggregation descriptors
+    expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),count(s2),first_value(s3)"};
+    retArray =
+        new String[] {
+          "root.sg1.d2,1314000000001,13.15,4,11,",
+          "root.sg1.d3,1314000000002,13.16,2,4,",
+          "root.sg1.d4,5,5555.5,1,5555,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3) FROM root.sg1.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
 
-    // count_time(*)
+    retArray =
+        new String[] {
+          "root.sg2.d2,1314000000001,13.15,4,11,",
+          "root.sg2.d3,1314000000002,13.16,2,4,",
+          "root.sg2.d4,5,5555.5,1,5555,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3) FROM root.sg2.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
 
-    // agg operation expression : agg(s1+1)
+    // not supported: group by session, condition, agg(*), agg(s1+1), non-aligned template
 
     // duplicate select expressions
 
-    // non aligned template: sg1
-
     // filter cannot push down
 
     // having count(s1+s2)
@@ -122,10 +160,22 @@ public void aggregationTest() {
 
   @Test
   public void groupByTest() {
-    //
     String[] expectedHeader =
         new String[] {"Time,Device,max_time(s1),last_value(s1),last_value(s2)"};
     String[] retArray =
+        new String[] {
+          "1,root.sg1.d1,2,2.2,false,",
+          "5,root.sg1.d1,5,5.5,true,",
+          "1,root.sg1.d2,2,22.2,false,",
+          "5,root.sg1.d2,5,50.0,false,",
+          "1,root.sg1.d3,1,111.1,true,",
+        };
+    resultSetEqualTest(
+        "select max_time(s1), last_value(s1), last_value(s2) from root.sg1.** group by ([1,10), 2ms) having last_value(s2) is not null limit 5 align by device;",
+        expectedHeader,
+        retArray);
+    expectedHeader = new String[] {"Time,Device,max_time(s1),last_value(s1),last_value(s2)"};
+    retArray =
         new String[] {
           "1,root.sg2.d1,2,2.2,false,",
           "5,root.sg2.d1,5,5.5,true,",
@@ -140,6 +190,21 @@ public void groupByTest() {
 
     // sliding window
     expectedHeader = new String[] {"Time,Device,max_time(s1),last_value(s1),last_value(s2)"};
+    retArray =
+        new String[] {
+          "1,root.sg1.d1,2,2.2,false,",
+          "1,root.sg1.d2,2,22.2,false,",
+          "3,root.sg1.d2,5,50.0,false,",
+          "5,root.sg1.d2,5,50.0,false,",
+          "7,root.sg1.d3,8,8.8,false,",
+          "3,root.sg1.d4,5,5555.5,false,",
+          "5,root.sg1.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** where s3+1=1316 or s2=false group by ([1,10),3ms,2ms) having avg(s1)>0 align by device;",
+        expectedHeader,
+        retArray);
+    expectedHeader = new String[] {"Time,Device,max_time(s1),last_value(s1),last_value(s2)"};
     retArray =
         new String[] {
           "1,root.sg2.d1,2,2.2,false,",
@@ -160,6 +225,20 @@ public void groupByTest() {
   public void orderByTest() {
     String[] expectedHeader = new String[] {"Time,Device,sum(s3)"};
     String[] retArray =
+        new String[] {
+          "4,root.sg1.d1,5.0,",
+          "4,root.sg1.d2,5.0,",
+          "4,root.sg1.d3,44.0,",
+          "4,root.sg1.d4,5555.0,",
+          "2,root.sg1.d1,2.0,",
+        };
+    resultSetEqualTest(
+        "select sum(s3) from root.sg1.** where s1>1 GROUP BY([0, 10), 2ms) order by time desc offset 8 limit 5 align by device;",
+        expectedHeader,
+        retArray);
+
+    expectedHeader = new String[] {"Time,Device,sum(s3)"};
+    retArray =
         new String[] {
           "4,root.sg2.d1,5.0,",
           "4,root.sg2.d2,5.0,",
@@ -172,6 +251,20 @@ public void orderByTest() {
         expectedHeader,
         retArray);
 
+    expectedHeader = new String[] {"Time,Device,sum(s3)"};
+    retArray =
+        new String[] {
+          "0,root.sg1.d1,1.0,",
+          "2,root.sg1.d1,2.0,",
+          "4,root.sg1.d1,5.0,",
+          "0,root.sg1.d2,11.0,",
+          "2,root.sg1.d2,22.0,",
+        };
+    resultSetEqualTest(
+        "select sum(s3) from root.sg1.** where s1>1 GROUP BY([0, 10), 2ms) order by count(s2) desc limit 5 align by device;",
+        expectedHeader,
+        retArray);
+
     expectedHeader = new String[] {"Time,Device,sum(s3)"};
     retArray =
         new String[] {
@@ -187,6 +280,9 @@ public void orderByTest() {
         retArray);
 
     // order by non-existent measurement
+    assertTestFail(
+        "select sum(s3) from root.sg1.** where s1>1 order by count(s_null) desc limit 5 align by device;",
+        "count(s_null) in order by clause doesn't exist.");
     assertTestFail(
         "select sum(s3) from root.sg2.** where s1>1 order by count(s_null) desc limit 5 align by device;",
         "count(s_null) in order by clause doesn't exist.");
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index dc926303880a..1ba85d3a5c67 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -64,7 +64,8 @@ static boolean canBuildAggregationPlanUseTemplate(
       MPPQueryContext context,
       Template template) {
 
-    if (queryStatement.hasOrderByExpression()) {
+    // not support order by expression and non-aligned template
+    if (queryStatement.hasOrderByExpression() || !template.isDirectAligned()) {
       return false;
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
index d9981a97a91c..0ede9530b97c 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
@@ -80,9 +80,11 @@ public class TemplatedInfo {
   private Expression pushDownPredicate;
 
   // variables related to aggregation
-  private List<AggregationDescriptor> aggregationDescriptorList;
+  private final boolean aggregationQuery;
   private final GroupByTimeParameter groupByTimeParameter;
   private final boolean outputEndTime;
+  private List<AggregationDescriptor> ascendingDescriptorList;
+  private List<AggregationDescriptor> descendingDescriptorList;
 
   public TemplatedInfo(
       List<String> measurementList,
@@ -99,7 +101,7 @@ public TemplatedInfo(
       Map<String, IMeasurementSchema> schemaMap,
       Map<String, List<InputLocation>> filterLayoutMap,
       Expression pushDownPredicate,
-      List<AggregationDescriptor> aggregationDescriptorList,
+      boolean aggregationQuery,
       GroupByTimeParameter groupByTimeParameter,
       boolean outputEndTime) {
     this.measurementList = measurementList;
@@ -117,9 +119,9 @@ public TemplatedInfo(
       this.filterLayoutMap = filterLayoutMap;
     }
     this.pushDownPredicate = pushDownPredicate;
-
     this.schemaMap = schemaMap;
-    this.aggregationDescriptorList = aggregationDescriptorList;
+
+    this.aggregationQuery = aggregationQuery;
     this.groupByTimeParameter = groupByTimeParameter;
     this.outputEndTime = outputEndTime;
   }
@@ -199,12 +201,8 @@ public Expression[] getProjectExpressions() {
     return projectExpressions;
   }
 
-  public void setAggregationDescriptorList(List<AggregationDescriptor> aggregationDescriptorList) {
-    this.aggregationDescriptorList = aggregationDescriptorList;
-  }
-
-  public List<AggregationDescriptor> getAggregationDescriptorList() {
-    return this.aggregationDescriptorList;
+  public boolean isAggregationQuery() {
+    return aggregationQuery;
   }
 
   public GroupByTimeParameter getGroupByTimeParameter() {
@@ -215,6 +213,22 @@ public boolean isOutputEndTime() {
     return outputEndTime;
   }
 
+  public List<AggregationDescriptor> getAscendingDescriptorList() {
+    return this.ascendingDescriptorList;
+  }
+
+  public void setAscendingDescriptorList(List<AggregationDescriptor> ascendingDescriptorList) {
+    this.ascendingDescriptorList = ascendingDescriptorList;
+  }
+
+  public List<AggregationDescriptor> getDescendingDescriptorList() {
+    return this.descendingDescriptorList;
+  }
+
+  public void setDescendingDescriptorList(List<AggregationDescriptor> descendingDescriptorList) {
+    this.descendingDescriptorList = descendingDescriptorList;
+  }
+
   public static Map<String, List<InputLocation>> makeLayout(List<String> measurementList) {
     Map<String, List<InputLocation>> outputMappings = new LinkedHashMap<>();
     int tsBlockIndex = 0;
@@ -273,13 +287,6 @@ public void serialize(ByteBuffer byteBuffer) {
       ReadWriteIOUtils.write((byte) 0, byteBuffer);
     }
 
-    if (aggregationDescriptorList != null) {
-      ReadWriteIOUtils.write(aggregationDescriptorList.size(), byteBuffer);
-      aggregationDescriptorList.forEach(d -> d.serialize(byteBuffer));
-    } else {
-      ReadWriteIOUtils.write(0, byteBuffer);
-    }
-
     if (groupByTimeParameter != null) {
       ReadWriteIOUtils.write((byte) 1, byteBuffer);
       groupByTimeParameter.serialize(byteBuffer);
@@ -332,23 +339,29 @@ public void serialize(DataOutputStream stream) throws IOException {
       ReadWriteIOUtils.write((byte) 0, stream);
     }
 
-    if (aggregationDescriptorList != null) {
-      ReadWriteIOUtils.write(aggregationDescriptorList.size(), stream);
-      for (AggregationDescriptor descriptor : aggregationDescriptorList) {
+    if (aggregationQuery) {
+      ReadWriteIOUtils.write((byte) 1, stream);
+      if (groupByTimeParameter != null) {
+        ReadWriteIOUtils.write((byte) 1, stream);
+        groupByTimeParameter.serialize(stream);
+      } else {
+        ReadWriteIOUtils.write((byte) 0, stream);
+      }
+
+      ReadWriteIOUtils.write(outputEndTime, stream);
+
+      ReadWriteIOUtils.write(ascendingDescriptorList.size(), stream);
+      for (AggregationDescriptor descriptor : ascendingDescriptorList) {
         descriptor.serialize(stream);
       }
-    } else {
-      ReadWriteIOUtils.write(0, stream);
-    }
 
-    if (groupByTimeParameter != null) {
-      ReadWriteIOUtils.write((byte) 1, stream);
-      groupByTimeParameter.serialize(stream);
+      ReadWriteIOUtils.write(descendingDescriptorList.size(), stream);
+      for (AggregationDescriptor descriptor : descendingDescriptorList) {
+        descriptor.serialize(stream);
+      }
     } else {
       ReadWriteIOUtils.write((byte) 0, stream);
     }
-
-    ReadWriteIOUtils.write(outputEndTime, stream);
   }
 
   public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
@@ -415,40 +428,52 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
       pushDownPredicate = Expression.deserialize(byteBuffer);
     }
 
-    List<AggregationDescriptor> aggregationDescriptorList = null;
-    listSize = ReadWriteIOUtils.readInt(byteBuffer);
-    if (listSize > 0) {
-      aggregationDescriptorList = new ArrayList<>(listSize);
-      while (listSize-- > 0) {
-        aggregationDescriptorList.add(AggregationDescriptor.deserialize(byteBuffer));
+    boolean aggregationQuery = ReadWriteIOUtils.readBool(byteBuffer);
+    GroupByTimeParameter groupByTimeParameter = null;
+    boolean outputEndTime = ReadWriteIOUtils.readBool(byteBuffer);
+    List<AggregationDescriptor> ascendingDescriptorList = null;
+    List<AggregationDescriptor> descendingDescriptorList = null;
+
+    if (aggregationQuery) {
+      byte hasGroupByTime = ReadWriteIOUtils.readByte(byteBuffer);
+      if (hasGroupByTime == 1) {
+        groupByTimeParameter = GroupByTimeParameter.deserialize(byteBuffer);
       }
-    }
 
-    byte hasGroupByTime = ReadWriteIOUtils.readByte(byteBuffer);
-    GroupByTimeParameter groupByTimeParameter = null;
-    if (hasGroupByTime == 1) {
-      groupByTimeParameter = GroupByTimeParameter.deserialize(byteBuffer);
-    }
+      int size = ReadWriteIOUtils.readInt(byteBuffer);
+      ascendingDescriptorList = new ArrayList<>(size);
+      while (size-- > 0) {
+        ascendingDescriptorList.add(AggregationDescriptor.deserialize(byteBuffer));
+      }
 
-    boolean outputEndTime = ReadWriteIOUtils.readBool(byteBuffer);
+      size = ReadWriteIOUtils.readInt(byteBuffer);
+      descendingDescriptorList = new ArrayList<>(size);
+      while (size-- > 0) {
+        descendingDescriptorList.add(AggregationDescriptor.deserialize(byteBuffer));
+      }
+    }
 
-    return new TemplatedInfo(
-        measurementList,
-        measurementSchemaList,
-        dataTypeList,
-        scanOrder,
-        queryAllSensors,
-        selectMeasurements,
-        deviceToMeasurementIndexes,
-        offsetValue,
-        limitValue,
-        predicate,
-        keepNull,
-        measurementSchemaMap,
-        filterLayoutMap,
-        pushDownPredicate,
-        aggregationDescriptorList,
-        groupByTimeParameter,
-        outputEndTime);
+    TemplatedInfo templatedInfo =
+        new TemplatedInfo(
+            measurementList,
+            measurementSchemaList,
+            dataTypeList,
+            scanOrder,
+            queryAllSensors,
+            selectMeasurements,
+            deviceToMeasurementIndexes,
+            offsetValue,
+            limitValue,
+            predicate,
+            keepNull,
+            measurementSchemaMap,
+            filterLayoutMap,
+            pushDownPredicate,
+            aggregationQuery,
+            groupByTimeParameter,
+            outputEndTime);
+    templatedInfo.setAscendingDescriptorList(ascendingDescriptorList);
+    templatedInfo.setDescendingDescriptorList(descendingDescriptorList);
+    return templatedInfo;
   }
 }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index 1df1279903d0..e0567d3c69bd 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -288,7 +288,7 @@ public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterCon
                   context);
         } else {
           sourceNodeList =
-              constructSourceNodeFromAggregationDescriptors(
+              constructSourceNodeFromAggregationsDescriptors(
                   sourceToAscendingAggregationsMap,
                   sourceToDescendingAggregationsMap,
                   sourceToCountTimeAggregationsMap,
@@ -381,7 +381,7 @@ private void createAggregationDescriptor(
       }
     }
 
-    private List<PlanNode> constructSourceNodeFromAggregationDescriptors(
+    private List<PlanNode> constructSourceNodeFromAggregationsDescriptors(
         Map<PartialPath, List<AggregationDescriptor>> ascendingAggregations,
         Map<PartialPath, List<AggregationDescriptor>> descendingAggregations,
         Map<PartialPath, List<AggregationDescriptor>> countTimeAggregations,
@@ -404,7 +404,8 @@ private List<PlanNode> constructSourceNodeFromAggregationDescriptors(
                 pathAggregationsEntry.getValue(),
                 scanOrder,
                 groupByTimeParameter,
-                context));
+                context,
+                countTimeAggregations.isEmpty() ? (byte) 0 : (byte) 2));
       }
 
       boolean needCheckAscending = groupByTimeParameter == null;
@@ -419,7 +420,8 @@ private List<PlanNode> constructSourceNodeFromAggregationDescriptors(
                   pathAggregationsEntry.getValue(),
                   scanOrder.reverse(),
                   null,
-                  context));
+                  context,
+                  (byte) 1));
         }
       }
       return sourceNodeList;
@@ -454,7 +456,12 @@ private List<PlanNode> constructSourceNodeFromTemplateAggregationDescriptors(
         if (!aggregationDescriptors.isEmpty()) {
           sourceNodeList.add(
               createAggregationScanNode(
-                  alignedPath, aggregationDescriptors, scanOrder, groupByTimeParameter, context));
+                  alignedPath,
+                  aggregationDescriptors,
+                  scanOrder,
+                  groupByTimeParameter,
+                  context,
+                  (byte) 0));
         }
 
         if (needCheckAscending && !descendingAggregations.isEmpty()) {
@@ -464,43 +471,13 @@ private List<PlanNode> constructSourceNodeFromTemplateAggregationDescriptors(
                   .collect(Collectors.toList());
           sourceNodeList.add(
               createAggregationScanNode(
-                  alignedPath, aggregationDescriptors, scanOrder, groupByTimeParameter, context));
+                  alignedPath, aggregationDescriptors, scanOrder, null, context, (byte) 1));
         }
       } else {
-        // TODO verify the rightness of non-aligned series
-        for (int i = 0; i < measurementList.size(); i++) {
-          MeasurementPath measurementPath =
-              new MeasurementPath(
-                  devicePath.concatNode(measurementList.get(i)), measurementSchemaList.get(i));
-          for (List<AggregationDescriptor> aggregationDescriptorList :
-              descendingAggregations.values()) {
-            sourceNodeList.add(
-                createAggregationScanNode(
-                    measurementPath,
-                    aggregationDescriptorList,
-                    scanOrder,
-                    groupByTimeParameter,
-                    context));
-          }
-
-          if (needCheckAscending) {
-            for (List<AggregationDescriptor> aggregationDescriptorList :
-                descendingAggregations.values()) {
-              sourceNodeList.add(
-                  createAggregationScanNode(
-                      measurementPath,
-                      aggregationDescriptorList,
-                      scanOrder,
-                      groupByTimeParameter,
-                      context));
-            }
-          }
-        }
+        throw new IllegalStateException(
+            "Aggregation descriptors with non aligned template are not supported");
       }
 
-      // TODO count(s1+s2) is not supported
-      // TODO count_time is not supported
-
       return sourceNodeList;
     }
 
@@ -509,7 +486,8 @@ private SeriesAggregationSourceNode createAggregationScanNode(
         List<AggregationDescriptor> aggregationDescriptorList,
         Ordering scanOrder,
         GroupByTimeParameter groupByTimeParameter,
-        RewriterContext context) {
+        RewriterContext context,
+        byte descriptorType) {
       if (selectPath instanceof MeasurementPath) { // non-aligned series
         return new SeriesAggregationScanNode(
             context.genPlanNodeId(),
@@ -518,12 +496,15 @@ private SeriesAggregationSourceNode createAggregationScanNode(
             scanOrder,
             groupByTimeParameter);
       } else if (selectPath instanceof AlignedPath) { // aligned series
-        return new AlignedSeriesAggregationScanNode(
-            context.genPlanNodeId(),
-            (AlignedPath) selectPath,
-            aggregationDescriptorList,
-            scanOrder,
-            groupByTimeParameter);
+        AlignedSeriesAggregationScanNode aggScanNode =
+            new AlignedSeriesAggregationScanNode(
+                context.genPlanNodeId(),
+                (AlignedPath) selectPath,
+                aggregationDescriptorList,
+                scanOrder,
+                groupByTimeParameter);
+        aggScanNode.setDescriptorType(descriptorType);
+        return aggScanNode;
       } else {
         throw new IllegalArgumentException("unexpected path type");
       }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
index 0e48759983c4..c95fc4aaf83e 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
@@ -494,7 +494,7 @@ public Operator visitProject(ProjectNode node, LocalExecutionPlanContext context
     List<String> inputColumnNames;
     List<String> outputColumnNames = node.getOutputColumnNames();
     if (outputColumnNames == null) {
-      if (context.getTypeProvider().getTemplatedInfo().getAggregationDescriptorList() != null) {
+      if (context.getTypeProvider().getTemplatedInfo().isAggregationQuery()) {
         // TODO fix it
         // outputColumnNames is aggregation expression
         outputColumnNames = context.getTypeProvider().getTemplatedInfo().getDeviceViewOutputNames();
@@ -601,10 +601,17 @@ public Operator visitAlignedSeriesAggregationScan(
       AlignedSeriesAggregationScanNode node, LocalExecutionPlanContext context) {
     if (context.isBuildPlanUseTemplate()) {
       // TODO template situation, variables such as aggregator, scanOptions may be serialized once
+      List<AggregationDescriptor> aggregationDescriptors = null;
+      if (node.getDescriptorType() == 0 || node.getDescriptorType() == 2) {
+        aggregationDescriptors = context.getTemplatedInfo().getAscendingDescriptorList();
+      } else {
+        aggregationDescriptors = context.getTemplatedInfo().getDescendingDescriptorList();
+      }
+
       return constructAlignedSeriesAggregationScanOperator(
           node.getPlanNodeId(),
           node.getAlignedPath(),
-          context.getTemplatedInfo().getAggregationDescriptorList(),
+          aggregationDescriptors,
           context.getTemplatedInfo().getPushDownPredicate(),
           context.getTemplatedInfo().getScanOrder(),
           context.getTemplatedInfo().getGroupByTimeParameter(),
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
index 73b29b76f7f6..fd5b5dc0cb59 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
@@ -31,6 +31,7 @@
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationStep;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.InputLocation;
 import org.apache.iotdb.db.queryengine.plan.statement.crud.QueryStatement;
+import org.apache.iotdb.db.utils.SchemaUtils;
 
 import org.apache.commons.lang3.Validate;
 import org.apache.tsfile.enums.TSDataType;
@@ -158,7 +159,7 @@ private void initAggQueryCommonVariables() {
                 analysis.getDeviceTemplate().getSchemaMap(),
                 filterLayoutMap,
                 null,
-                null,
+                true,
                 analysis.getGroupByTimeParameter(),
                 queryStatement.isOutputEndTime()));
   }
@@ -216,7 +217,7 @@ private void initNonAggQueryCommonVariables() {
                 analysis.getDeviceTemplate().getSchemaMap(),
                 filterLayoutMap,
                 null,
-                null,
+                false,
                 analysis.getGroupByTimeParameter(),
                 queryStatement.isOutputEndTime()));
   }
@@ -316,10 +317,22 @@ private PlanNode visitAggregation() {
         new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList);
     Map<String, PlanNode> deviceToSubPlanMap = new LinkedHashMap<>();
     aggregationDescriptorList = getDeduplicatedDescriptors(aggregationDescriptorList);
-    context
-        .getTypeProvider()
-        .getTemplatedInfo()
-        .setAggregationDescriptorList(aggregationDescriptorList);
+
+    boolean needCheckAscending = queryStatement.isGroupByTime();
+    List<AggregationDescriptor> ascendingDescriptors = new ArrayList<>();
+    List<AggregationDescriptor> descendingDescriptors = new ArrayList<>();
+    for (AggregationDescriptor aggregationDescriptor : aggregationDescriptorList) {
+      if (needCheckAscending
+          || SchemaUtils.isConsistentWithScanOrder(
+              aggregationDescriptor.getAggregationType(), queryStatement.getResultTimeOrder())) {
+        ascendingDescriptors.add(aggregationDescriptor);
+      } else {
+        descendingDescriptors.add(aggregationDescriptor);
+      }
+    }
+    context.getTypeProvider().getTemplatedInfo().setAscendingDescriptorList(ascendingDescriptors);
+    context.getTypeProvider().getTemplatedInfo().setDescendingDescriptorList(descendingDescriptors);
+
     for (PartialPath devicePath : analysis.getDeviceList()) {
       String deviceName = devicePath.getFullPath();
       PlanNode rootNode = visitDeviceAggregationBody(devicePath, curStep);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java
index 755119b26075..5c4e19fe99d3 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java
@@ -210,6 +210,9 @@ public DistributedQueryPlan planFragments() {
     // Mark the root Fragment of root SubPlan as `root`
     subPlan.getPlanFragment().setRoot(true);
     List<FragmentInstance> fragmentInstances = planFragmentInstances(subPlan);
+    for (FragmentInstance fragmentInstance : fragmentInstances) {
+      System.out.println("===" + fragmentInstance);
+    }
     // Only execute this step for READ operation
     if (context.getQueryType() == QueryType.READ) {
       setSinkForRootInstance(subPlan, fragmentInstances);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
index adaad506184c..4fc9a7a88d0f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
@@ -55,6 +55,12 @@ public class AlignedSeriesAggregationScanNode extends SeriesAggregationSourceNod
   // The id of DataRegion where the node will run
   private TRegionReplicaSet regionReplicaSet;
 
+  // this variable is only used in aggregation align by device query, with all devices in one
+  // template,
+  // 0 represent ascending descriptors, 1 represent descending descriptors, 2 represent count_time
+  // descriptors
+  private byte descriptorType;
+
   public AlignedSeriesAggregationScanNode(
       PlanNodeId id,
       AlignedPath alignedPath,
@@ -97,7 +103,8 @@ public AlignedSeriesAggregationScanNode(
       boolean outputEndTime,
       @Nullable Expression pushDownPredicate,
       @Nullable GroupByTimeParameter groupByTimeParameter,
-      TRegionReplicaSet dataRegionReplicaSet) {
+      TRegionReplicaSet dataRegionReplicaSet,
+      byte descriptorType) {
     this(
         id,
         alignedPath,
@@ -107,6 +114,7 @@ public AlignedSeriesAggregationScanNode(
         groupByTimeParameter,
         dataRegionReplicaSet);
     setOutputEndTime(outputEndTime);
+    setDescriptorType(descriptorType);
   }
 
   public AlignedPath getAlignedPath() {
@@ -117,9 +125,12 @@ public void setAlignedPath(AlignedPath alignedPath) {
     this.alignedPath = alignedPath;
   }
 
-  @Override
-  public Ordering getScanOrder() {
-    return scanOrder;
+  public byte getDescriptorType() {
+    return this.descriptorType;
+  }
+
+  public void setDescriptorType(byte descriptorType) {
+    this.descriptorType = descriptorType;
   }
 
   @Override
@@ -173,7 +184,8 @@ public PlanNode clone() {
         isOutputEndTime(),
         getPushDownPredicate(),
         getGroupByTimeParameter(),
-        getRegionReplicaSet());
+        getRegionReplicaSet(),
+        getDescriptorType());
   }
 
   @Override
@@ -257,7 +269,8 @@ public static AlignedSeriesAggregationScanNode deserialize(ByteBuffer byteBuffer
         outputEndTime,
         pushDownPredicate,
         groupByTimeParameter,
-        null);
+        null,
+        (byte) 0);
   }
 
   @Override
@@ -269,6 +282,7 @@ public void serializeUseTemplate(DataOutputStream stream, TypeProvider typeProvi
     for (String node : alignedPath.getNodes()) {
       ReadWriteIOUtils.write(node, stream);
     }
+    ReadWriteIOUtils.write(descriptorType, stream);
   }
 
   public static AlignedSeriesAggregationScanNode deserializeUseTemplate(
@@ -283,16 +297,24 @@ public static AlignedSeriesAggregationScanNode deserializeUseTemplate(
     AlignedPath alignedPath = new AlignedPath(new PartialPath(nodes));
     alignedPath.setMeasurementList(typeProvider.getTemplatedInfo().getMeasurementList());
     alignedPath.addSchemas(typeProvider.getTemplatedInfo().getSchemaList());
+    byte descriptorType = ReadWriteIOUtils.readByte(byteBuffer);
+    List<AggregationDescriptor> aggregationDescriptorList = null;
+    if (descriptorType == 0 || descriptorType == 2) {
+      aggregationDescriptorList = typeProvider.getTemplatedInfo().getAscendingDescriptorList();
+    } else if (descriptorType == 1) {
+      aggregationDescriptorList = typeProvider.getTemplatedInfo().getDescendingDescriptorList();
+    }
 
     return new AlignedSeriesAggregationScanNode(
         planNodeId,
         alignedPath,
-        typeProvider.getTemplatedInfo().getAggregationDescriptorList(),
+        aggregationDescriptorList,
         typeProvider.getTemplatedInfo().getScanOrder(),
         typeProvider.getTemplatedInfo().isOutputEndTime(),
         typeProvider.getTemplatedInfo().getPushDownPredicate(),
         typeProvider.getTemplatedInfo().getGroupByTimeParameter(),
-        null);
+        null,
+        descriptorType);
   }
 
   @Override

From ef77dc5dff3d9df86dd82abc2d2393143928949b Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Sun, 26 May 2024 22:49:44 +0800
Subject: [PATCH 20/28] fix merge error in TemplatedAnalyze

---
 .../plan/analyze/TemplatedAnalyze.java        | 81 +++++++++----------
 1 file changed, 37 insertions(+), 44 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
index a2b753ec7061..c564ed59c9c0 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
@@ -122,57 +122,50 @@ public static boolean canBuildPlanUseTemplate(
         new ColumnPaginationController(
             queryStatement.getSeriesLimit(), queryStatement.getSeriesOffset());
 
-    if (template != null) {
-      for (ResultColumn resultColumn : queryStatement.getSelectComponent().getResultColumns()) {
-        Expression expression = resultColumn.getExpression();
-        if ("*".equals(expression.getOutputSymbol())) {
-          for (Map.Entry<String, IMeasurementSchema> entry : template.getSchemaMap().entrySet()) {
-            if (paginationController.hasCurOffset()) {
-              paginationController.consumeOffset();
-            } else if (paginationController.hasCurLimit()) {
-              String measurementName = entry.getKey();
-              IMeasurementSchema measurementSchema = entry.getValue();
-              TimeSeriesOperand measurementPath =
-                  new TimeSeriesOperand(
-                      new MeasurementPath(new String[] {measurementName}, measurementSchema));
-              // reserve memory for this expression
-              context.reserveMemoryForFrontEnd(measurementPath.ramBytesUsed());
-              outputExpressions.add(new Pair<>(measurementPath, null));
-              paginationController.consumeLimit();
-            } else {
-              break;
-            }
+    for (ResultColumn resultColumn : queryStatement.getSelectComponent().getResultColumns()) {
+      Expression expression = resultColumn.getExpression();
+      if ("*".equals(expression.getOutputSymbol())) {
+        for (Map.Entry<String, IMeasurementSchema> entry : template.getSchemaMap().entrySet()) {
+          if (paginationController.hasCurOffset()) {
+            paginationController.consumeOffset();
+          } else if (paginationController.hasCurLimit()) {
+            String measurementName = entry.getKey();
+            IMeasurementSchema measurementSchema = entry.getValue();
+            TimeSeriesOperand measurementPath =
+                new TimeSeriesOperand(
+                    new MeasurementPath(new String[] {measurementName}, measurementSchema));
+            // reserve memory for this expression
+            context.reserveMemoryForFrontEnd(measurementPath.ramBytesUsed());
+            outputExpressions.add(new Pair<>(measurementPath, null));
+            paginationController.consumeLimit();
+          } else {
+            break;
           }
-          if (queryStatement.getSelectComponent().getResultColumns().size() == 1
-              && queryStatement.getSeriesOffset() == 0
-              && queryStatement.getSeriesLimit() == 0) {
-            analysis.setTemplateWildCardQuery();
-          }
-        } else if (expression instanceof TimeSeriesOperand) {
-          String measurementName = ((TimeSeriesOperand) expression).getPath().getMeasurement();
-          if (template.getSchemaMap().containsKey(measurementName)) {
-            if (paginationController.hasCurOffset()) {
-              paginationController.consumeOffset();
-            } else if (paginationController.hasCurLimit()) {
-              IMeasurementSchema measurementSchema = template.getSchemaMap().get(measurementName);
-              TimeSeriesOperand measurementPath =
-                  new TimeSeriesOperand(
-                      new MeasurementPath(new String[] {measurementName}, measurementSchema));
-              // reserve memory for this expression
-              context.reserveMemoryForFrontEnd(measurementPath.ramBytesUsed());
-              outputExpressions.add(new Pair<>(measurementPath, resultColumn.getAlias()));
-            } else {
-              break;
-            }
-          }
-        } else {
-          return false;
         }
         if (queryStatement.getSelectComponent().getResultColumns().size() == 1
             && queryStatement.getSeriesOffset() == 0
             && queryStatement.getSeriesLimit() == 0) {
           analysis.setTemplateWildCardQuery();
         }
+      } else if (expression instanceof TimeSeriesOperand) {
+        String measurementName = ((TimeSeriesOperand) expression).getPath().getMeasurement();
+        if (template.getSchemaMap().containsKey(measurementName)) {
+          if (paginationController.hasCurOffset()) {
+            paginationController.consumeOffset();
+          } else if (paginationController.hasCurLimit()) {
+            IMeasurementSchema measurementSchema = template.getSchemaMap().get(measurementName);
+            TimeSeriesOperand measurementPath =
+                new TimeSeriesOperand(
+                    new MeasurementPath(new String[] {measurementName}, measurementSchema));
+            // reserve memory for this expression
+            context.reserveMemoryForFrontEnd(measurementPath.ramBytesUsed());
+            outputExpressions.add(new Pair<>(measurementPath, resultColumn.getAlias()));
+          } else {
+            break;
+          }
+        }
+      } else {
+        return false;
       }
     }
 

From 2a1b868cd6af89f3a529b979963b4144b867720b Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Mon, 27 May 2024 11:35:41 +0800
Subject: [PATCH 21/28] fix outputEndTime serialize in templateInfo. remove
 redundant judgements in ExpressionTypeAnalyzer

---
 ...TDBAlignByDeviceWithTemplateAggregationIT.java | 10 +++++-----
 .../plan/analyze/ExpressionTypeAnalyzer.java      | 15 ---------------
 .../queryengine/plan/analyze/TemplatedInfo.java   |  4 +++-
 .../planner/distribution/DistributionPlanner.java |  4 +---
 4 files changed, 9 insertions(+), 24 deletions(-)

diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
index eda3b484697b..f1b36008f6d0 100644
--- a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
@@ -92,13 +92,13 @@ public void aggregationTest() {
     expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),last_value(s2)"};
     retArray =
         new String[] {
-          "root.sg1.d1,1314000000000,13.14,true,",
-          "root.sg1.d2,1314000000001,13.15,false,",
-          "root.sg1.d3,1314000000002,13.16,false,",
-          "root.sg1.d4,1314000000003,13.14,true,",
+          "root.sg2.d1,1314000000000,13.14,true,",
+          "root.sg2.d2,1314000000001,13.15,false,",
+          "root.sg2.d3,1314000000002,13.16,false,",
+          "root.sg2.d4,1314000000003,13.14,true,",
         };
     resultSetEqualTest(
-        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** align by device;",
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** align by device;",
         expectedHeader,
         retArray);
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
index 6868b6122744..92550ecf788b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
@@ -19,7 +19,6 @@
 
 package org.apache.iotdb.db.queryengine.plan.analyze;
 
-import org.apache.iotdb.commons.path.MeasurementPath;
 import org.apache.iotdb.db.exception.sql.SemanticException;
 import org.apache.iotdb.db.queryengine.common.NodeRef;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
@@ -102,13 +101,6 @@ public static void analyzeExpressionUsingTemplatedInfo(
     ExpressionTypeAnalyzer analyzer = new ExpressionTypeAnalyzer();
 
     Map<String, IMeasurementSchema> schemaMap = templatedInfo.getSchemaMap();
-    if (schemaMap == null) {
-      schemaMap = new LinkedHashMap<>();
-      for (int i = 0; i < templatedInfo.getMeasurementList().size(); i++) {
-        schemaMap.put(
-            templatedInfo.getMeasurementList().get(i), templatedInfo.getSchemaList().get(i));
-      }
-    }
     analyzer.analyze(expression, schemaMap);
 
     types.putAll(analyzer.getExpressionTypes());
@@ -360,13 +352,6 @@ public TSDataType visitTimeSeriesOperand(
             timeSeriesOperand, context.get(timeSeriesOperand.getOutputSymbol()).getType());
       }
 
-      if (context != null
-          && !(timeSeriesOperand.getPath() instanceof MeasurementPath)
-          && context.containsKey(timeSeriesOperand.getPath().getFullPath())) {
-        return setExpressionType(
-            timeSeriesOperand, context.get(timeSeriesOperand.getPath().getFullPath()).getType());
-      }
-
       return setExpressionType(timeSeriesOperand, timeSeriesOperand.getPath().getSeriesType());
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
index 0ede9530b97c..752c58393dc9 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
@@ -430,7 +430,7 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
 
     boolean aggregationQuery = ReadWriteIOUtils.readBool(byteBuffer);
     GroupByTimeParameter groupByTimeParameter = null;
-    boolean outputEndTime = ReadWriteIOUtils.readBool(byteBuffer);
+    boolean outputEndTime = false;
     List<AggregationDescriptor> ascendingDescriptorList = null;
     List<AggregationDescriptor> descendingDescriptorList = null;
 
@@ -440,6 +440,8 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
         groupByTimeParameter = GroupByTimeParameter.deserialize(byteBuffer);
       }
 
+      outputEndTime = ReadWriteIOUtils.readBool(byteBuffer);
+
       int size = ReadWriteIOUtils.readInt(byteBuffer);
       ascendingDescriptorList = new ArrayList<>(size);
       while (size-- > 0) {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java
index 5c4e19fe99d3..c2ca7011039c 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java
@@ -210,9 +210,7 @@ public DistributedQueryPlan planFragments() {
     // Mark the root Fragment of root SubPlan as `root`
     subPlan.getPlanFragment().setRoot(true);
     List<FragmentInstance> fragmentInstances = planFragmentInstances(subPlan);
-    for (FragmentInstance fragmentInstance : fragmentInstances) {
-      System.out.println("===" + fragmentInstance);
-    }
+
     // Only execute this step for READ operation
     if (context.getQueryType() == QueryType.READ) {
       setSinkForRootInstance(subPlan, fragmentInstances);

From 126f856f537957f87294128306f5925750214ec1 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Mon, 27 May 2024 17:29:53 +0800
Subject: [PATCH 22/28] add count_time support, add more its

---
 ...lignByDeviceWithTemplateAggregationIT.java | 128 +++++++++++++++++-
 .../plan/analyze/AnalyzeVisitor.java          |   2 +-
 .../analyze/TemplatedAggregationAnalyze.java  |  78 ++++++-----
 .../plan/analyze/TemplatedInfo.java           |  31 +++--
 .../optimization/AggregationPushDown.java     |  32 ++++-
 .../plan/planner/TemplatedLogicalPlan.java    |   5 +
 6 files changed, 224 insertions(+), 52 deletions(-)

diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
index f1b36008f6d0..c2e599439b10 100644
--- a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
@@ -149,13 +149,133 @@ public void aggregationTest() {
         expectedHeader,
         retArray);
 
-    // not supported: group by session, condition, agg(*), agg(s1+1), non-aligned template
-
     // duplicate select expressions
+    expectedHeader =
+        new String[] {
+          "Device,max_time(s1),last_value(s1),count(s2),first_value(s3),last_value(s1)"
+        };
+    retArray =
+        new String[] {
+          "root.sg1.d2,1314000000001,13.15,4,11,13.15,",
+          "root.sg1.d3,1314000000002,13.16,2,4,13.16,",
+          "root.sg1.d4,5,5555.5,1,5555,5555.5,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3), last_value(s1) FROM root.sg1.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d2,1314000000001,13.15,4,11,13.15,",
+          "root.sg2.d3,1314000000002,13.16,2,4,13.16,",
+          "root.sg2.d4,5,5555.5,1,5555,5555.5,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3), last_value(s1) FROM root.sg2.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
 
-    // filter cannot push down
+    // alias
+    expectedHeader = new String[] {"Device,c1,first_value(s3),c2"};
+    retArray =
+        new String[] {
+          "root.sg1.d2,4,11,4,", "root.sg1.d3,2,4,2,", "root.sg1.d4,1,5555,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count(s1) as c1, first_value(s3), count(s1) as c2 FROM root.sg1.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d2,4,11,4,", "root.sg2.d3,2,4,2,", "root.sg2.d4,1,5555,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count(s1) as c1, first_value(s3), count(s1) as c2 FROM root.sg2.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
 
-    // having count(s1+s2)
+    // arithmetic expression
+    expectedHeader =
+        new String[] {"Device,max_time(s1),count(s1),last_value(s2),count(s1) + last_value(s3)"};
+    retArray =
+        new String[] {
+          "root.sg1.d2,1314000000001,4,false,1319.0,",
+          "root.sg1.d3,1314000000002,2,false,1318.0,",
+          "root.sg1.d4,5,1,false,5556.0,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), count(s1), last_value(s2), count(s1)+last_value(s3) FROM root.sg1.** where s3+1=1316 or s2=false having avg(s1)+sum(s3)>5 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d2,1314000000001,4,false,1319.0,",
+          "root.sg2.d3,1314000000002,2,false,1318.0,",
+          "root.sg2.d4,5,1,false,5556.0,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), count(s1), last_value(s2), count(s1)+last_value(s3) FROM root.sg2.** where s3+1=1316 or s2=false having avg(s1)+sum(s3)>5 align by device;",
+        expectedHeader,
+        retArray);
+
+    // __endTime result is ambiguous
+
+    // not supported: group by session, condition, agg(*), agg(s1+1), count(s1+s2), non-aligned
+    // template
+  }
+
+  @Test
+  public void countTimeTest() {
+    String[] expectedHeader = new String[] {"Device,count_time(*)"};
+    String[] retArray =
+        new String[] {
+          "root.sg1.d1,2,", "root.sg1.d2,4,", "root.sg1.d3,2,", "root.sg1.d4,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg1.** where s3+1=1316 or s2=false align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,2,", "root.sg2.d2,4,", "root.sg2.d3,2,", "root.sg2.d4,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg2.** where s3+1=1316 or s2=false align by device;",
+        expectedHeader,
+        retArray);
+
+    expectedHeader = new String[] {"Time,Device,count_time(*)"};
+    retArray =
+        new String[] {
+          "1,root.sg1.d1,2,",
+          "6,root.sg1.d1,0,",
+          "1,root.sg1.d2,3,",
+          "6,root.sg1.d2,0,",
+          "1,root.sg1.d3,0,",
+          "6,root.sg1.d3,1,",
+          "1,root.sg1.d4,1,",
+          "6,root.sg1.d4,0,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg1.** where s3+1=1316 or s2=false group by ([1,10), 5ms) align by device;",
+        expectedHeader,
+        retArray);
+    expectedHeader = new String[] {"Time,Device,count_time(*)"};
+    retArray =
+        new String[] {
+          "1,root.sg2.d1,2,",
+          "6,root.sg2.d1,0,",
+          "1,root.sg2.d2,3,",
+          "6,root.sg2.d2,0,",
+          "1,root.sg2.d3,0,",
+          "6,root.sg2.d3,1,",
+          "1,root.sg2.d4,1,",
+          "6,root.sg2.d4,0,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg2.** where s3+1=1316 or s2=false group by ([1,10), 5ms) align by device;",
+        expectedHeader,
+        retArray);
   }
 
   @Test
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
index 1f5e1b098c19..90908302cf1d 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
@@ -209,7 +209,7 @@ public class AnalyzeVisitor extends StatementVisitor<Analysis, MPPQueryContext>
   static final Expression DEVICE_EXPRESSION =
       TimeSeriesOperand.constructColumnHeaderExpression(DEVICE, TSDataType.TEXT);
 
-  static final Expression END_TIME_EXPRESSION =
+  public static final Expression END_TIME_EXPRESSION =
       TimeSeriesOperand.constructColumnHeaderExpression(ENDTIME, TSDataType.INT64);
 
   private final List<String> lastQueryColumnNames =
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index 1ba85d3a5c67..93934000c9ff 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -21,9 +21,12 @@
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.db.exception.sql.SemanticException;
 import org.apache.iotdb.db.queryengine.common.MPPQueryContext;
+import org.apache.iotdb.db.queryengine.common.NodeRef;
 import org.apache.iotdb.db.queryengine.common.schematree.ISchemaTree;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.expression.leaf.ConstantOperand;
+import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimestampOperand;
+import org.apache.iotdb.db.queryengine.plan.expression.multi.FunctionExpression;
 import org.apache.iotdb.db.queryengine.plan.statement.component.ResultColumn;
 import org.apache.iotdb.db.queryengine.plan.statement.crud.QueryStatement;
 import org.apache.iotdb.db.schemaengine.template.Template;
@@ -33,11 +36,13 @@
 import org.apache.tsfile.write.schema.IMeasurementSchema;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 
+import static org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant.ENDTIME;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.DEVICE_EXPRESSION;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.END_TIME_EXPRESSION;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeExpressionType;
@@ -99,10 +104,7 @@ static boolean canBuildAggregationPlanUseTemplate(
     }
 
     analyzeHaving(analysis, queryStatement);
-
-    analyzeDeviceToAggregation(analysis);
-    analyzeDeviceToSourceTransform(analysis);
-    analyzeDeviceToSource(analysis);
+    analyzeDeviceToExpressions(analysis);
 
     analyzeDeviceViewOutput(analysis, queryStatement);
     analyzeDeviceViewInput(analysis, queryStatement);
@@ -124,6 +126,8 @@ private static boolean analyzeSelect(
       List<Pair<Expression, String>> outputExpressions,
       Template template) {
 
+    analysis.setDeviceTemplate(template);
+
     LinkedHashSet<Expression> selectExpressions = new LinkedHashSet<>();
     selectExpressions.add(DEVICE_EXPRESSION);
     if (queryStatement.isOutputEndTime()) {
@@ -143,35 +147,50 @@ private static boolean analyzeSelect(
         outputExpressions.add(new Pair<>(selectExpression, resultColumn.getAlias()));
         selectExpressions.add(selectExpression);
         aggregationExpressions.add(selectExpression);
+        if (selectExpression instanceof FunctionExpression
+            && "count_time"
+                .equalsIgnoreCase(((FunctionExpression) selectExpression).getFunctionName())) {
+          analysis.getExpressionTypes().put(NodeRef.of(selectExpression), TSDataType.INT64);
+          ((FunctionExpression) selectExpression)
+              .setExpressions(Collections.singletonList(new TimestampOperand()));
+        } else {
+          analyzeExpressionType(analysis, selectExpression);
+        }
       } else {
         break;
       }
     }
 
-    analysis.setDeviceTemplate(template);
     List<String> measurementList = new ArrayList<>();
     List<IMeasurementSchema> measurementSchemaList = new ArrayList<>();
     Set<String> measurementSet = new HashSet<>();
-    for (Expression selectExpression : selectExpressions) {
-      if ("device".equalsIgnoreCase(selectExpression.getOutputSymbol())) {
-        continue;
-      }
-
-      String measurement = selectExpression.getExpressions().get(0).getOutputSymbol();
-      if (!template.getSchemaMap().containsKey(measurement)) {
-        analysis.setDeviceTemplate(null);
-        // TODO not support agg(*), agg(s1+1), count_time(*) now
-        return false;
-      }
 
-      // for agg1(s1) + agg2(s1), only record s1 for one time
-      if (!measurementSet.contains(measurement)) {
-        measurementSet.add(measurement);
-        measurementList.add(measurement);
-        measurementSchemaList.add(template.getSchemaMap().get(measurement));
+    if (queryStatement.isCountTimeAggregation()) {
+      measurementList = new ArrayList<>(template.getSchemaMap().keySet());
+      measurementSchemaList = new ArrayList<>(template.getSchemaMap().values());
+    } else {
+      int idx = 0;
+      for (Expression selectExpression : selectExpressions) {
+        idx++;
+        if (idx == 1
+            || (idx == 2 && ENDTIME.equalsIgnoreCase(selectExpression.getOutputSymbol()))) {
+          continue;
+        }
+
+        String measurement = selectExpression.getExpressions().get(0).getOutputSymbol();
+        //  not support agg(*), agg(s1+1) now
+        if (!template.getSchemaMap().containsKey(measurement)) {
+          analysis.setDeviceTemplate(null);
+          return false;
+        }
+
+        // for agg1(s1) + agg2(s1), only record s1 for one time
+        if (!measurementSet.contains(measurement)) {
+          measurementSet.add(measurement);
+          measurementList.add(measurement);
+          measurementSchemaList.add(template.getSchemaMap().get(measurement));
+        }
       }
-
-      analyzeExpressionType(analysis, selectExpression);
     }
 
     analysis.setMeasurementList(measurementList);
@@ -187,12 +206,8 @@ private static void analyzeHaving(Analysis analysis, QueryStatement queryStateme
       return;
     }
 
-    // TODO not support having count(s1) + sum(s2) expression
     Set<Expression> aggregationExpressions = analysis.getAggregationExpressions();
-
     Expression havingExpression = queryStatement.getHavingCondition().getPredicate();
-
-    // Set<Expression> normalizedAggregationExpressions = new LinkedHashSet<>();
     for (Expression aggregationExpression : searchAggregationExpressions(havingExpression)) {
       Expression normalizedAggregationExpression = normalizeExpression(aggregationExpression);
 
@@ -200,7 +215,6 @@ private static void analyzeHaving(Analysis analysis, QueryStatement queryStateme
       analyzeExpressionType(analysis, normalizedAggregationExpression);
 
       aggregationExpressions.add(aggregationExpression);
-      // normalizedAggregationExpressions.add(normalizedAggregationExpression);
     }
 
     TSDataType outputType = analyzeExpressionType(analysis, havingExpression);
@@ -213,18 +227,12 @@ private static void analyzeHaving(Analysis analysis, QueryStatement queryStateme
     analysis.setHavingExpression(havingExpression);
   }
 
-  private static void analyzeDeviceToSourceTransform(Analysis analysis) {
-    // TODO add having into SourceTransform
+  private static void analyzeDeviceToExpressions(Analysis analysis) {
     analysis.setDeviceToSourceTransformExpressions(analysis.getDeviceToSelectExpressions());
-  }
 
-  private static void analyzeDeviceToSource(Analysis analysis) {
     analysis.setDeviceToSourceExpressions(analysis.getDeviceToSelectExpressions());
     analysis.setDeviceToOutputExpressions(analysis.getDeviceToSelectExpressions());
-  }
 
-  private static void analyzeDeviceToAggregation(Analysis analysis) {
-    // TODO need add having clause?
     analysis.setDeviceToAggregationExpressions(analysis.getDeviceToSelectExpressions());
   }
 }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
index 752c58393dc9..298a6e8ec088 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
@@ -260,8 +260,8 @@ public void serialize(ByteBuffer byteBuffer) {
     ReadWriteIOUtils.write(queryAllSensors, byteBuffer);
 
     ReadWriteIOUtils.write(deviceViewOutputNames.size(), byteBuffer);
-    for (String selectMeasurement : deviceViewOutputNames) {
-      ReadWriteIOUtils.write(selectMeasurement, byteBuffer);
+    for (String outputName : deviceViewOutputNames) {
+      ReadWriteIOUtils.write(outputName, byteBuffer);
     }
 
     ReadWriteIOUtils.write(deviceToMeasurementIndexes.size(), byteBuffer);
@@ -287,14 +287,29 @@ public void serialize(ByteBuffer byteBuffer) {
       ReadWriteIOUtils.write((byte) 0, byteBuffer);
     }
 
-    if (groupByTimeParameter != null) {
+    if (aggregationQuery) {
       ReadWriteIOUtils.write((byte) 1, byteBuffer);
-      groupByTimeParameter.serialize(byteBuffer);
+      if (groupByTimeParameter != null) {
+        ReadWriteIOUtils.write((byte) 1, byteBuffer);
+        groupByTimeParameter.serialize(byteBuffer);
+      } else {
+        ReadWriteIOUtils.write((byte) 0, byteBuffer);
+      }
+
+      ReadWriteIOUtils.write(outputEndTime, byteBuffer);
+
+      ReadWriteIOUtils.write(ascendingDescriptorList.size(), byteBuffer);
+      for (AggregationDescriptor descriptor : ascendingDescriptorList) {
+        descriptor.serialize(byteBuffer);
+      }
+
+      ReadWriteIOUtils.write(descendingDescriptorList.size(), byteBuffer);
+      for (AggregationDescriptor descriptor : descendingDescriptorList) {
+        descriptor.serialize(byteBuffer);
+      }
     } else {
       ReadWriteIOUtils.write((byte) 0, byteBuffer);
     }
-
-    ReadWriteIOUtils.write(outputEndTime, byteBuffer);
   }
 
   public void serialize(DataOutputStream stream) throws IOException {
@@ -312,8 +327,8 @@ public void serialize(DataOutputStream stream) throws IOException {
     ReadWriteIOUtils.write(queryAllSensors, stream);
 
     ReadWriteIOUtils.write(deviceViewOutputNames.size(), stream);
-    for (String selectMeasurement : deviceViewOutputNames) {
-      ReadWriteIOUtils.write(selectMeasurement, stream);
+    for (String outputName : deviceViewOutputNames) {
+      ReadWriteIOUtils.write(outputName, stream);
     }
 
     ReadWriteIOUtils.write(deviceToMeasurementIndexes.size(), stream);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index 5b8031038d8e..4676f1907f24 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -107,9 +107,7 @@ private boolean cannotUseStatistics(QueryStatement queryStatement, Analysis anal
     boolean isAlignByDevice = queryStatement.isAlignByDevice();
     if (isAlignByDevice) {
       if (analysis.allDevicesInOneTemplate()) {
-        // TODO agg+template situation, how about the SourceTransformExpressions
-        return cannotUseStatistics(
-            analysis.getAggregationExpressions(), analysis.getAggregationExpressions());
+        return cannotUseStatisticsForTemplate(analysis.getAggregationExpressions());
       }
 
       // check any of the devices
@@ -125,8 +123,8 @@ private boolean cannotUseStatistics(QueryStatement queryStatement, Analysis anal
 
   private boolean cannotUseStatistics(
       Set<Expression> aggregationExpressions, Set<Expression> sourceTransformExpressions) {
-    for (Expression expression : aggregationExpressions) {
 
+    for (Expression expression : aggregationExpressions) {
       if (expression instanceof FunctionExpression) {
         FunctionExpression functionExpression = (FunctionExpression) expression;
         // Disable statistics optimization of UDAF for now
@@ -163,6 +161,32 @@ private boolean cannotUseStatistics(
     return false;
   }
 
+  private boolean cannotUseStatisticsForTemplate(Set<Expression> aggregationExpressions) {
+
+    for (Expression expression : aggregationExpressions) {
+      if (expression instanceof FunctionExpression) {
+        FunctionExpression functionExpression = (FunctionExpression) expression;
+        // Disable statistics optimization of UDAF for now
+        if (functionExpression.isExternalAggregationFunctionExpression()) {
+          return true;
+        }
+
+        // in template align by device query, device must be aligned
+        if (COUNT_TIME.equalsIgnoreCase(functionExpression.getFunctionName())) {
+          return false;
+        }
+
+        if (!BuiltinAggregationFunction.canUseStatistics(functionExpression.getFunctionName())) {
+          return true;
+        }
+      } else {
+        throw new IllegalArgumentException(
+            String.format("Invalid Aggregation Expression: %s", expression.getExpressionString()));
+      }
+    }
+    return false;
+  }
+
   private static class Rewriter extends PlanVisitor<PlanNode, RewriterContext> {
 
     @Override
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
index fd5b5dc0cb59..26cbe31651f1 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
@@ -48,6 +48,7 @@
 
 import static org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant.DEVICE;
 import static org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant.ENDTIME;
+import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.END_TIME_EXPRESSION;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.searchSourceExpressions;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedInfo.makeLayout;
 import static org.apache.iotdb.db.queryengine.plan.planner.LogicalPlanBuilder.updateTypeProviderByPartialAggregation;
@@ -137,6 +138,10 @@ private void initAggQueryCommonVariables() {
                   context.getTypeProvider().setType(key.getNode().getOutputSymbol(), value));
     }
 
+    if (queryStatement.isOutputEndTime()) {
+      context.getTypeProvider().setType(END_TIME_EXPRESSION.getOutputSymbol(), TSDataType.INT64);
+    }
+
     context
         .getTypeProvider()
         .setTemplatedInfo(

From d86728d74b89ba8bed4e41b51f48dbab1eddc9bd Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Mon, 27 May 2024 22:23:33 +0800
Subject: [PATCH 23/28] fix select agg where s1>1 bug which is aggreagtion
 pushdown situation

---
 ...lignByDeviceWithTemplateAggregationIT.java |  39 ++++-
 .../analyze/TemplatedAggregationAnalyze.java  |   8 +-
 .../plan/analyze/TemplatedAnalyze.java        |   1 -
 .../optimization/AggregationPushDown.java     | 136 +++++++++++++++---
 .../plan/planner/OperatorTreeGenerator.java   |  37 ++---
 .../plan/planner/TemplatedLogicalPlan.java    |   8 +-
 .../planner/TemplatedLogicalPlanBuilder.java  |   1 -
 7 files changed, 173 insertions(+), 57 deletions(-)

diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
index c2e599439b10..17dc59d05167 100644
--- a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
@@ -102,8 +102,16 @@ public void aggregationTest() {
         expectedHeader,
         retArray);
 
-    // value filter + having
-    retArray =
+    // __endTime result is ambiguous
+
+    // not supported: group by session, condition, agg(*), agg(s1+1), count(s1+s2), non-aligned
+    // template
+  }
+
+  @Test
+  public void filterTest() {
+    String[] expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),last_value(s2)"};
+    String[] retArray =
         new String[] {
           "root.sg1.d2,1314000000001,13.15,false,",
           "root.sg1.d3,1314000000002,13.16,false,",
@@ -218,10 +226,29 @@ public void aggregationTest() {
         expectedHeader,
         retArray);
 
-    // __endTime result is ambiguous
-
-    // not supported: group by session, condition, agg(*), agg(s1+1), count(s1+s2), non-aligned
-    // template
+    expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),count(s2),first_value(s3)"};
+    retArray =
+        new String[] {
+          "root.sg1.d1,1314000000000,13.14,3,2,",
+          "root.sg1.d2,1314000000001,13.15,4,11,",
+          "root.sg1.d3,1314000000002,13.16,3,44,",
+          "root.sg1.d4,1314000000003,13.14,4,1111,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3) FROM root.sg1.** where s3>1 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,1314000000000,13.14,3,2,",
+          "root.sg2.d2,1314000000001,13.15,4,11,",
+          "root.sg2.d3,1314000000002,13.16,3,44,",
+          "root.sg2.d4,1314000000003,13.14,4,1111,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3) FROM root.sg2.** where s3>1 align by device;",
+        expectedHeader,
+        retArray);
   }
 
   @Test
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index 93934000c9ff..dd56dd0d5dbd 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -44,7 +44,6 @@
 
 import static org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant.ENDTIME;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.DEVICE_EXPRESSION;
-import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.END_TIME_EXPRESSION;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeExpressionType;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeGroupByTime;
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeOutput;
@@ -125,15 +124,14 @@ private static boolean analyzeSelect(
       Analysis analysis,
       List<Pair<Expression, String>> outputExpressions,
       Template template) {
-
-    analysis.setDeviceTemplate(template);
-
     LinkedHashSet<Expression> selectExpressions = new LinkedHashSet<>();
     selectExpressions.add(DEVICE_EXPRESSION);
     if (queryStatement.isOutputEndTime()) {
-      selectExpressions.add(END_TIME_EXPRESSION);
+      return false;
     }
 
+    analysis.setDeviceTemplate(template);
+
     ColumnPaginationController paginationController =
         new ColumnPaginationController(
             queryStatement.getSeriesLimit(), queryStatement.getSeriesOffset());
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
index c564ed59c9c0..2d8bd8c39c55 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
@@ -372,7 +372,6 @@ static void analyzeDeviceViewInput(Analysis analysis, QueryStatement queryStatem
     List<Integer> indexes = new ArrayList<>();
 
     if (queryStatement.isAggregationQuery()) {
-      // TODO verify the rightness of order
       for (int i = 1; i <= analysis.getAggregationExpressions().size(); i++) {
         indexes.add(i);
       }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index 4676f1907f24..131a9bbb1d98 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -273,6 +273,10 @@ public PlanNode visitGroupByTag(GroupByTagNode node, RewriterContext context) {
 
     @Override
     public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterContext context) {
+      if (context.analysis.allDevicesInOneTemplate()) {
+        return visitRawDataAggregationTemplateCase(node, context);
+      }
+
       PlanNode child = node.getChild();
       if (child instanceof ProjectNode) {
         // remove ProjectNode
@@ -311,26 +315,14 @@ public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterCon
               sourceToCountTimeAggregationsMap);
         }
 
-        List<PlanNode> sourceNodeList;
-        if (context.analysis.allDevicesInOneTemplate()) {
-          sourceNodeList =
-              constructSourceNodeFromTemplateAggregationDescriptors(
-                  sourceToAscendingAggregationsMap,
-                  sourceToDescendingAggregationsMap,
-                  sourceToCountTimeAggregationsMap,
-                  node.getScanOrder(),
-                  node.getGroupByTimeParameter(),
-                  context);
-        } else {
-          sourceNodeList =
-              constructSourceNodeFromAggregationsDescriptors(
-                  sourceToAscendingAggregationsMap,
-                  sourceToDescendingAggregationsMap,
-                  sourceToCountTimeAggregationsMap,
-                  node.getScanOrder(),
-                  node.getGroupByTimeParameter(),
-                  context);
-        }
+        List<PlanNode> sourceNodeList =
+            constructSourceNodeFromAggregationsDescriptors(
+                sourceToAscendingAggregationsMap,
+                sourceToDescendingAggregationsMap,
+                sourceToCountTimeAggregationsMap,
+                node.getScanOrder(),
+                node.getGroupByTimeParameter(),
+                context);
 
         if (isSingleSource && ((SeriesScanSourceNode) child).getPushDownPredicate() != null) {
           Expression pushDownPredicate = ((SeriesScanSourceNode) child).getPushDownPredicate();
@@ -479,6 +471,69 @@ private List<PlanNode> constructSourceNodeFromAggregationsDescriptors(
       return sourceNodeList;
     }
 
+    public PlanNode visitRawDataAggregationTemplateCase(
+        RawDataAggregationNode node, RewriterContext context) {
+      PlanNode child = node.getChild();
+
+      if (child instanceof ProjectNode) {
+        node.setChild(((ProjectNode) child).getChild());
+        return visitRawDataAggregation(node, context);
+      }
+
+      if (child instanceof FullOuterTimeJoinNode || child instanceof SeriesScanSourceNode) {
+        boolean isSingleSource = child instanceof SeriesScanSourceNode;
+        boolean needCheckAscending = node.getGroupByTimeParameter() == null;
+        if (isSingleSource && ((SeriesScanSourceNode) child).getPushDownPredicate() != null) {
+          needCheckAscending = false;
+          Expression pushDownPredicate = ((SeriesScanSourceNode) child).getPushDownPredicate();
+          if (!PredicateUtils.predicateCanPushIntoScan(pushDownPredicate)) {
+            // don't push down, simplify the BE side logic
+            return node;
+          }
+        }
+
+        List<PlanNode> sourceNodeList =
+            newConstructSourceNodeFromTemplateAggregationDescriptors(
+                context
+                    .getContext()
+                    .getTypeProvider()
+                    .getTemplatedInfo()
+                    .getAscendingDescriptorList(),
+                context
+                    .getContext()
+                    .getTypeProvider()
+                    .getTemplatedInfo()
+                    .getDescendingDescriptorList(),
+                node.getScanOrder(),
+                node.getGroupByTimeParameter(),
+                context);
+
+        if (isSingleSource && ((SeriesScanSourceNode) child).getPushDownPredicate() != null) {
+          Expression pushDownPredicate = ((SeriesScanSourceNode) child).getPushDownPredicate();
+          sourceNodeList.forEach(
+              sourceNode -> {
+                SeriesAggregationSourceNode aggregationSourceNode =
+                    (SeriesAggregationSourceNode) sourceNode;
+                aggregationSourceNode.setPushDownPredicate(pushDownPredicate);
+                if (aggregationSourceNode instanceof AlignedSeriesAggregationScanNode) {
+                  ((AlignedSeriesAggregationScanNode) aggregationSourceNode)
+                      .setAlignedPath(((AlignedSeriesScanNode) child).getAlignedPath());
+                }
+              });
+        }
+
+        PlanNode resultNode = convergeWithTimeJoin(sourceNodeList, node.getScanOrder(), context);
+        resultNode = planProject(resultNode, node, context);
+
+        // After pushing down the predicate, the original scan nodes are no longer needed, we should
+        // release the memory that they occupied.
+        context.releaseMemoryForFrontEnd(getRamBytesUsedOfOldScanNodes(child));
+        return resultNode;
+      }
+      // cannot push down
+      return node;
+    }
+
     private List<PlanNode> constructSourceNodeFromTemplateAggregationDescriptors(
         Map<PartialPath, List<AggregationDescriptor>> ascendingAggregations,
         Map<PartialPath, List<AggregationDescriptor>> descendingAggregations,
@@ -533,6 +588,47 @@ private List<PlanNode> constructSourceNodeFromTemplateAggregationDescriptors(
       return sourceNodeList;
     }
 
+    private List<PlanNode> newConstructSourceNodeFromTemplateAggregationDescriptors(
+        List<AggregationDescriptor> ascendingAggregations,
+        List<AggregationDescriptor> descendingAggregations,
+        Ordering scanOrder,
+        GroupByTimeParameter groupByTimeParameter,
+        RewriterContext context) {
+
+      List<PlanNode> sourceNodeList = new ArrayList<>();
+      PartialPath devicePath = context.curDevicePath;
+      List<String> measurementList = context.analysis.getMeasurementList();
+      List<IMeasurementSchema> measurementSchemaList = context.analysis.getMeasurementSchemaList();
+      boolean needCheckAscending = groupByTimeParameter == null;
+
+      if (!context.analysis.getDeviceTemplate().isDirectAligned()) {
+        throw new IllegalStateException(
+            "Aggregation descriptors with non aligned template are not supported");
+      }
+      AlignedPath alignedPath = new AlignedPath(devicePath);
+      alignedPath.setMeasurementList(measurementList);
+      alignedPath.addSchemas(measurementSchemaList);
+
+      if (!ascendingAggregations.isEmpty()) {
+        sourceNodeList.add(
+            createAggregationScanNode(
+                alignedPath,
+                ascendingAggregations,
+                scanOrder,
+                groupByTimeParameter,
+                context,
+                (byte) 0));
+      }
+
+      if (needCheckAscending && !descendingAggregations.isEmpty()) {
+        sourceNodeList.add(
+            createAggregationScanNode(
+                alignedPath, descendingAggregations, scanOrder, null, context, (byte) 1));
+      }
+
+      return sourceNodeList;
+    }
+
     private SeriesAggregationSourceNode createAggregationScanNode(
         PartialPath selectPath,
         List<AggregationDescriptor> aggregationDescriptorList,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
index c95fc4aaf83e..9933ac2966a6 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
@@ -291,6 +291,8 @@
 import static org.apache.iotdb.db.queryengine.plan.expression.leaf.TimestampOperand.TIMESTAMP_EXPRESSION_STRING;
 import static org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationDescriptor.getAggregationTypeByFuncName;
 import static org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.SeriesScanOptions.updateFilterUsingTTL;
+import static org.apache.iotdb.db.queryengine.plan.statement.component.Ordering.ASC;
+import static org.apache.iotdb.db.queryengine.plan.statement.component.Ordering.DESC;
 import static org.apache.iotdb.db.utils.TimestampPrecisionUtils.TIMESTAMP_PRECISION;
 
 /** This Visitor is responsible for transferring PlanNode Tree to Operator Tree. */
@@ -531,7 +533,7 @@ public Operator visitProject(ProjectNode node, LocalExecutionPlanContext context
   public Operator visitSeriesAggregationScan(
       SeriesAggregationScanNode node, LocalExecutionPlanContext context) {
     PartialPath seriesPath = node.getSeriesPath();
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
     List<Aggregator> aggregators = new ArrayList<>();
     aggregationDescriptors.forEach(
@@ -600,11 +602,12 @@ public Operator visitSeriesAggregationScan(
   public Operator visitAlignedSeriesAggregationScan(
       AlignedSeriesAggregationScanNode node, LocalExecutionPlanContext context) {
     if (context.isBuildPlanUseTemplate()) {
-      // TODO template situation, variables such as aggregator, scanOptions may be serialized once
+      Ordering scanOrder = ASC;
       List<AggregationDescriptor> aggregationDescriptors = null;
       if (node.getDescriptorType() == 0 || node.getDescriptorType() == 2) {
         aggregationDescriptors = context.getTemplatedInfo().getAscendingDescriptorList();
       } else {
+        scanOrder = DESC;
         aggregationDescriptors = context.getTemplatedInfo().getDescendingDescriptorList();
       }
 
@@ -613,7 +616,7 @@ public Operator visitAlignedSeriesAggregationScan(
           node.getAlignedPath(),
           aggregationDescriptors,
           context.getTemplatedInfo().getPushDownPredicate(),
-          context.getTemplatedInfo().getScanOrder(),
+          scanOrder,
           context.getTemplatedInfo().getGroupByTimeParameter(),
           context.getTemplatedInfo().isOutputEndTime(),
           context);
@@ -639,7 +642,7 @@ private Operator constructAlignedSeriesAggregationScanOperator(
       GroupByTimeParameter groupByTimeParameter,
       boolean outputEndTime,
       LocalExecutionPlanContext context) {
-    boolean ascending = scanOrder == Ordering.ASC;
+    boolean ascending = scanOrder == ASC;
     List<Aggregator> aggregators = new ArrayList<>();
     for (AggregationDescriptor descriptor : aggregationDescriptorList) {
       checkArgument(
@@ -1438,7 +1441,7 @@ public Operator visitTransform(TransformNode node, LocalExecutionPlanContext con
           node.isKeepNull(),
           context.getZoneId(),
           expressionTypes,
-          node.getScanOrder() == Ordering.ASC);
+          node.getScanOrder() == ASC);
     } catch (QueryProcessException e) {
       throw new RuntimeException(e);
     }
@@ -1625,7 +1628,7 @@ private Operator constructFilterOperator(
           isKeepNull,
           context.getZoneId(),
           expressionTypes,
-          scanOrder == Ordering.ASC);
+          scanOrder == ASC);
     } catch (QueryProcessException e) {
       throw new RuntimeException(e);
     }
@@ -1637,7 +1640,7 @@ public Operator visitGroupByLevel(GroupByLevelNode node, LocalExecutionPlanConte
         !node.getGroupByLevelDescriptors().isEmpty(),
         "GroupByLevel descriptorList cannot be empty");
     List<Operator> children = dealWithConsumeAllChildrenPipelineBreaker(node, context);
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     List<Aggregator> aggregators = new ArrayList<>();
     Map<String, List<InputLocation>> layout = makeLayout(node);
     List<CrossSeriesAggregationDescriptor> aggregationDescriptors =
@@ -1694,7 +1697,7 @@ public Operator visitGroupByTag(GroupByTagNode node, LocalExecutionPlanContext c
 
     List<Operator> children = dealWithConsumeAllChildrenPipelineBreaker(node, context);
 
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     Map<String, List<InputLocation>> layout = makeLayout(node);
     List<List<String>> groups = new ArrayList<>();
     List<List<Aggregator>> groupedAggregators = new ArrayList<>();
@@ -1767,7 +1770,7 @@ public Operator visitSlidingWindowAggregation(
                 node.getPlanNodeId(),
                 SlidingWindowAggregationOperator.class.getSimpleName());
     Operator child = node.getChild().accept(this, context);
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     List<Aggregator> aggregators = new ArrayList<>();
     Map<String, List<InputLocation>> layout = makeLayout(node);
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
@@ -1867,7 +1870,7 @@ private RawDataAggregationOperator createRawDataAggregationOperator(
         !node.getAggregationDescriptorList().isEmpty(),
         "Aggregation descriptorList cannot be empty");
     Operator child = node.getChild().accept(this, context);
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     List<Aggregator> aggregators = new ArrayList<>();
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
     for (AggregationDescriptor descriptor : node.getAggregationDescriptorList()) {
@@ -1992,7 +1995,7 @@ public Operator visitAggregation(AggregationNode node, LocalExecutionPlanContext
         !node.getAggregationDescriptorList().isEmpty(),
         "Aggregation descriptorList cannot be empty");
     List<Operator> children = dealWithConsumeAllChildrenPipelineBreaker(node, context);
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     List<Aggregator> aggregators = new ArrayList<>();
     Map<String, List<InputLocation>> layout = makeLayout(node);
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
@@ -2275,7 +2278,7 @@ public Operator visitFullOuterTimeJoin(
                 node.getPlanNodeId(),
                 FullOuterTimeJoinOperator.class.getSimpleName());
     TimeComparator timeComparator =
-        node.getMergeOrder() == Ordering.ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
+        node.getMergeOrder() == ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
     List<OutputColumn> outputColumns = generateOutputColumnsFromChildren(node);
     List<ColumnMerger> mergers = createColumnMergers(outputColumns, timeComparator);
     List<TSDataType> outputColumnTypes =
@@ -2305,7 +2308,7 @@ public Operator visitInnerTimeJoin(InnerTimeJoinNode node, LocalExecutionPlanCon
                 node.getPlanNodeId(),
                 InnerTimeJoinOperator.class.getSimpleName());
     TimeComparator timeComparator =
-        node.getMergeOrder() == Ordering.ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
+        node.getMergeOrder() == ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
     List<TSDataType> outputColumnTypes =
         context.getTypeProvider().getTemplatedInfo() != null
             ? getOutputColumnTypesOfTimeJoinNode(node)
@@ -2359,7 +2362,7 @@ public Operator visitLeftOuterTimeJoin(
                 node.getPlanNodeId(),
                 LeftOuterTimeJoinOperator.class.getSimpleName());
     TimeComparator timeComparator =
-        node.getMergeOrder() == Ordering.ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
+        node.getMergeOrder() == ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
     List<TSDataType> outputColumnTypes =
         context.getTypeProvider().getTemplatedInfo() != null
             ? getOutputColumnTypesOfTimeJoinNode(node)
@@ -2860,9 +2863,7 @@ public Operator visitLastQuery(LastQueryNode node, LocalExecutionPlanContext con
     } else {
       // order by timeseries
       Comparator<Binary> comparator =
-          node.getTimeseriesOrdering() == Ordering.ASC
-              ? ASC_BINARY_COMPARATOR
-              : DESC_BINARY_COMPARATOR;
+          node.getTimeseriesOrdering() == ASC ? ASC_BINARY_COMPARATOR : DESC_BINARY_COMPARATOR;
       // sort values from last cache
       if (initSize > 0) {
         cachedLastValueAndPathList.sort(Comparator.comparing(Pair::getRight, comparator));
@@ -2906,7 +2907,7 @@ public Operator visitLastQueryMerge(LastQueryMergeNode node, LocalExecutionPlanC
 
     Ordering timeseriesOrdering = node.getTimeseriesOrdering();
     Comparator<Binary> comparator =
-        (timeseriesOrdering == null || timeseriesOrdering == Ordering.ASC)
+        (timeseriesOrdering == null || timeseriesOrdering == ASC)
             ? ASC_BINARY_COMPARATOR
             : DESC_BINARY_COMPARATOR;
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
index 26cbe31651f1..3517c81d0d94 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
@@ -84,8 +84,6 @@ public class TemplatedLogicalPlan {
 
   List<AggregationDescriptor> aggregationDescriptorList;
 
-  List<AggregationDescriptor> deduplicatedDescriptors;
-
   public TemplatedLogicalPlan(
       Analysis analysis, QueryStatement queryStatement, MPPQueryContext context) {
     this.analysis = analysis;
@@ -128,7 +126,6 @@ private void initAggQueryCommonVariables() {
         }
       }
 
-      // TODO fix aggregation filterLayoutMap
       filterLayoutMap = makeLayout(newMeasurementList);
 
       analysis
@@ -340,7 +337,7 @@ private PlanNode visitAggregation() {
 
     for (PartialPath devicePath : analysis.getDeviceList()) {
       String deviceName = devicePath.getFullPath();
-      PlanNode rootNode = visitDeviceAggregationBody(devicePath, curStep);
+      PlanNode rootNode = visitDeviceAggregationBody(devicePath);
 
       LogicalPlanBuilder subPlanBuilder =
           new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList)
@@ -381,7 +378,7 @@ private PlanNode visitAggregation() {
     return templatedPlanBuilder.getRoot();
   }
 
-  private PlanNode visitDeviceAggregationBody(PartialPath devicePath, AggregationStep curStep) {
+  private PlanNode visitDeviceAggregationBody(PartialPath devicePath) {
     TemplatedLogicalPlanBuilder templatedPlanBuilder =
         new TemplatedLogicalPlanBuilder(analysis, context, newMeasurementList, newSchemaList);
 
@@ -403,7 +400,6 @@ private PlanNode visitDeviceAggregationBody(PartialPath devicePath, AggregationS
                 analysis.getGroupByTimeParameter(),
                 analysis.getGroupByParameter(),
                 queryStatement.isOutputEndTime(),
-                curStep,
                 queryStatement.getResultTimeOrder(),
                 aggregationDescriptorList)
             .planSlidingWindowAggregation(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
index 1d8350ba0075..e615a7600a9b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
@@ -149,7 +149,6 @@ public TemplatedLogicalPlanBuilder planRawDataAggregation(
       GroupByTimeParameter groupByTimeParameter,
       GroupByParameter groupByParameter,
       boolean outputEndTime,
-      AggregationStep curStep,
       Ordering scanOrder,
       List<AggregationDescriptor> deduplicatedAggregationDescriptorList) {
     if (aggregationExpressions == null) {

From d596aa7c52ace15acb6bfc6f518dd5747f0ac4b2 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Tue, 28 May 2024 12:16:42 +0800
Subject: [PATCH 24/28] perfect logic of deviceToMeasurementIndexes, remove
 analyzeDeviceInputIndex; fix count_time; add more it;

---
 ...lignByDeviceWithTemplateAggregationIT.java | 36 +++++++++++++++++++
 .../analyze/TemplatedAggregationAnalyze.java  |  2 --
 .../plan/analyze/TemplatedAnalyze.java        | 22 ------------
 .../plan/analyze/TemplatedInfo.java           |  6 +++-
 .../plan/planner/OperatorTreeGenerator.java   | 27 ++++++++------
 .../plan/planner/TemplatedLogicalPlan.java    | 22 ++++++++++--
 .../plan/node/process/DeviceViewNode.java     |  8 +----
 7 files changed, 77 insertions(+), 46 deletions(-)

diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
index 17dc59d05167..c2a55cda30f3 100644
--- a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
@@ -253,8 +253,43 @@ public void filterTest() {
 
   @Test
   public void countTimeTest() {
+    // no filter
     String[] expectedHeader = new String[] {"Device,count_time(*)"};
     String[] retArray =
+        new String[] {
+          "root.sg1.d1,4,", "root.sg1.d2,4,", "root.sg1.d3,4,", "root.sg1.d4,4,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg1.** align by device;", expectedHeader, retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,4,", "root.sg2.d2,4,", "root.sg2.d3,4,", "root.sg2.d4,4,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg2.** align by device;", expectedHeader, retArray);
+
+    // and filter
+    expectedHeader = new String[] {"Device,count_time(*)"};
+    retArray =
+        new String[] {
+          "root.sg1.d1,2,", "root.sg1.d2,4,", "root.sg1.d3,2,", "root.sg1.d4,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg1.** where s3>0 and s2=false align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,2,", "root.sg2.d2,4,", "root.sg2.d3,2,", "root.sg2.d4,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg2.** where s3>0 and s2=false align by device;",
+        expectedHeader,
+        retArray);
+
+    // or filter
+    expectedHeader = new String[] {"Device,count_time(*)"};
+    retArray =
         new String[] {
           "root.sg1.d1,2,", "root.sg1.d2,4,", "root.sg1.d3,2,", "root.sg1.d4,1,",
         };
@@ -271,6 +306,7 @@ public void countTimeTest() {
         expectedHeader,
         retArray);
 
+    // group by
     expectedHeader = new String[] {"Time,Device,count_time(*)"};
     retArray =
         new String[] {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index dd56dd0d5dbd..56a8c5d290aa 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -51,7 +51,6 @@
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.searchAggregationExpressions;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDataPartition;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDeviceToWhere;
-import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDeviceViewInput;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDeviceViewOutput;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeFrom;
 import static org.apache.iotdb.db.queryengine.plan.optimization.LimitOffsetPushDown.canPushDownLimitOffsetInGroupByTimeForDevice;
@@ -106,7 +105,6 @@ static boolean canBuildAggregationPlanUseTemplate(
     analyzeDeviceToExpressions(analysis);
 
     analyzeDeviceViewOutput(analysis, queryStatement);
-    analyzeDeviceViewInput(analysis, queryStatement);
 
     // generate result set header according to output expressions
     analyzeOutput(analysis, queryStatement, outputExpressions);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
index 2d8bd8c39c55..a1fcb4c18ee1 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
@@ -196,7 +196,6 @@ public static boolean canBuildPlanUseTemplate(
     analyzeDeviceToSource(analysis);
 
     analyzeDeviceViewOutput(analysis, queryStatement);
-    analyzeDeviceViewInput(analysis, queryStatement);
 
     analyzeFill(analysis, queryStatement);
 
@@ -368,27 +367,6 @@ static void analyzeDeviceViewOutput(Analysis analysis, QueryStatement queryState
         analyzeDeviceViewSpecialProcess(deviceViewOutputExpressions, queryStatement, analysis));
   }
 
-  static void analyzeDeviceViewInput(Analysis analysis, QueryStatement queryStatement) {
-    List<Integer> indexes = new ArrayList<>();
-
-    if (queryStatement.isAggregationQuery()) {
-      for (int i = 1; i <= analysis.getAggregationExpressions().size(); i++) {
-        indexes.add(i);
-      }
-    } else {
-      for (int i = 1; i < analysis.getSelectExpressions().size(); i++) {
-        indexes.add(i);
-      }
-    }
-
-    // TODO only store once
-    Map<String, List<Integer>> deviceViewInputIndexesMap = new HashMap<>();
-    for (PartialPath devicePath : analysis.getDeviceList()) {
-      deviceViewInputIndexesMap.put(devicePath.getFullPath(), indexes);
-    }
-    analysis.setDeviceViewInputIndexesMap(deviceViewInputIndexesMap);
-  }
-
   private static void analyzeDeviceToSource(Analysis analysis) {
     analysis.setDeviceToSourceExpressions(analysis.getDeviceToSelectExpressions());
     analysis.setDeviceToOutputExpressions(analysis.getDeviceToSelectExpressions());
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
index 298a6e8ec088..919efa8970c2 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
@@ -61,7 +61,7 @@ public class TemplatedInfo {
 
   // variables used in DeviceViewOperator
   private final List<String> deviceViewOutputNames;
-  private final List<Integer> deviceToMeasurementIndexes;
+  private List<Integer> deviceToMeasurementIndexes;
 
   // variables related to LIMIT/OFFSET push down
   private final long offsetValue;
@@ -162,6 +162,10 @@ public List<Integer> getDeviceToMeasurementIndexes() {
     return this.deviceToMeasurementIndexes;
   }
 
+  public void setDeviceToMeasurementIndexes(List<Integer> deviceToMeasurementIndexes) {
+    this.deviceToMeasurementIndexes = deviceToMeasurementIndexes;
+  }
+
   public Expression getPredicate() {
     return this.predicate;
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
index 9933ac2966a6..0e3c2b47e517 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
@@ -292,7 +292,6 @@
 import static org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationDescriptor.getAggregationTypeByFuncName;
 import static org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.SeriesScanOptions.updateFilterUsingTTL;
 import static org.apache.iotdb.db.queryengine.plan.statement.component.Ordering.ASC;
-import static org.apache.iotdb.db.queryengine.plan.statement.component.Ordering.DESC;
 import static org.apache.iotdb.db.utils.TimestampPrecisionUtils.TIMESTAMP_PRECISION;
 
 /** This Visitor is responsible for transferring PlanNode Tree to Operator Tree. */
@@ -497,11 +496,9 @@ public Operator visitProject(ProjectNode node, LocalExecutionPlanContext context
     List<String> outputColumnNames = node.getOutputColumnNames();
     if (outputColumnNames == null) {
       if (context.getTypeProvider().getTemplatedInfo().isAggregationQuery()) {
-        // TODO fix it
-        // outputColumnNames is aggregation expression
         outputColumnNames = context.getTypeProvider().getTemplatedInfo().getDeviceViewOutputNames();
         outputColumnNames = outputColumnNames.subList(1, outputColumnNames.size());
-        inputColumnNames = outputColumnNames;
+        inputColumnNames = node.getChild().getOutputColumnNames();
       } else {
         outputColumnNames = context.getTypeProvider().getTemplatedInfo().getDeviceViewOutputNames();
         // skip device column
@@ -602,12 +599,12 @@ public Operator visitSeriesAggregationScan(
   public Operator visitAlignedSeriesAggregationScan(
       AlignedSeriesAggregationScanNode node, LocalExecutionPlanContext context) {
     if (context.isBuildPlanUseTemplate()) {
-      Ordering scanOrder = ASC;
-      List<AggregationDescriptor> aggregationDescriptors = null;
+      Ordering scanOrder = context.getTemplatedInfo().getScanOrder();
+      List<AggregationDescriptor> aggregationDescriptors;
       if (node.getDescriptorType() == 0 || node.getDescriptorType() == 2) {
         aggregationDescriptors = context.getTemplatedInfo().getAscendingDescriptorList();
       } else {
-        scanOrder = DESC;
+        scanOrder = scanOrder.reverse();
         aggregationDescriptors = context.getTemplatedInfo().getDescendingDescriptorList();
       }
 
@@ -1016,10 +1013,18 @@ public Operator visitDeviceView(DeviceViewNode node, LocalExecutionPlanContext c
                 node.getPlanNodeId(),
                 DeviceViewOperator.class.getSimpleName());
     List<Operator> children = dealWithConsumeChildrenOneByOneNode(node, context);
-    List<List<Integer>> deviceColumnIndex =
-        node.getDevices().stream()
-            .map(deviceName -> node.getDeviceToMeasurementIndexesMap().get(deviceName))
-            .collect(Collectors.toList());
+    List<List<Integer>> deviceColumnIndex = new ArrayList<>(node.getDevices().size());
+    if (context.getTemplatedInfo() != null) {
+      for (int i = 0; i < node.getDevices().size(); i++) {
+        deviceColumnIndex.add(context.getTemplatedInfo().getDeviceToMeasurementIndexes());
+      }
+    } else {
+      deviceColumnIndex =
+          node.getDevices().stream()
+              .map(deviceName -> node.getDeviceToMeasurementIndexesMap().get(deviceName))
+              .collect(Collectors.toList());
+    }
+
     List<TSDataType> outputColumnTypes = getOutputColumnTypes(node, context.getTypeProvider());
 
     return new DeviceViewOperator(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
index 3517c81d0d94..496053635e5d 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
@@ -138,6 +138,16 @@ private void initAggQueryCommonVariables() {
     if (queryStatement.isOutputEndTime()) {
       context.getTypeProvider().setType(END_TIME_EXPRESSION.getOutputSymbol(), TSDataType.INT64);
     }
+    if (queryStatement.isCountTimeAggregation()) {
+      context.getTypeProvider().setType("count_time(*)", TSDataType.INT64);
+      context.getTypeProvider().setType("count_time(Time)", TSDataType.INT64);
+    }
+
+    List<Integer> deviceToMeasurementIndexes =
+        new ArrayList<>(analysis.getSelectExpressions().size() - 1);
+    for (int i = 1; i <= analysis.getAggregationExpressions().size(); i++) {
+      deviceToMeasurementIndexes.add(i);
+    }
 
     context
         .getTypeProvider()
@@ -153,7 +163,7 @@ private void initAggQueryCommonVariables() {
                 analysis.getDeviceViewOutputExpressions().stream()
                     .map(Expression::getExpressionString)
                     .collect(Collectors.toList()),
-                analysis.getDeviceViewInputIndexesMap().values().iterator().next(),
+                deviceToMeasurementIndexes,
                 OFFSET_VALUE,
                 limitValue,
                 whereExpression,
@@ -197,6 +207,12 @@ private void initNonAggQueryCommonVariables() {
                   context.getTypeProvider().setType(key.getNode().getOutputSymbol(), value));
     }
 
+    List<Integer> deviceToMeasurementIndexes =
+        new ArrayList<>(analysis.getSelectExpressions().size() - 1);
+    for (int i = 1; i < analysis.getSelectExpressions().size(); i++) {
+      deviceToMeasurementIndexes.add(i);
+    }
+
     context
         .getTypeProvider()
         .setTemplatedInfo(
@@ -211,7 +227,7 @@ private void initNonAggQueryCommonVariables() {
                 analysis.getDeviceViewOutputExpressions().stream()
                     .map(Expression::getExpressionString)
                     .collect(Collectors.toList()),
-                analysis.getDeviceViewInputIndexesMap().values().iterator().next(),
+                deviceToMeasurementIndexes,
                 OFFSET_VALUE,
                 limitValue,
                 whereExpression,
@@ -351,7 +367,7 @@ private PlanNode visitAggregation() {
             .planDeviceView(
                 deviceToSubPlanMap,
                 analysis.getDeviceViewOutputExpressions(),
-                analysis.getDeviceViewInputIndexesMap(),
+                null,
                 analysis.getSelectExpressions(),
                 queryStatement,
                 analysis)
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java
index dcb29879365b..b6114e1f1272 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java
@@ -238,18 +238,12 @@ public static DeviceViewNode deserializeUseTemplate(
       devicesSize--;
     }
 
-    Map<String, List<Integer>> deviceToMeasurementIndexesMap = new HashMap<>(devices.size());
-    for (String deviceName : devices) {
-      deviceToMeasurementIndexesMap.put(
-          deviceName, typeProvider.getTemplatedInfo().getDeviceToMeasurementIndexes());
-    }
-
     return new DeviceViewNode(
         planNodeId,
         mergeOrderParameter,
         typeProvider.getTemplatedInfo().getDeviceViewOutputNames(),
         devices,
-        deviceToMeasurementIndexesMap);
+        null);
   }
 
   @Override

From 29caf67ab5a878705865c5d3f0dc9b544aec2e94 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Tue, 28 May 2024 13:05:01 +0800
Subject: [PATCH 25/28] fix deviceToMeasurementIdx error in
 SingleDeviceViewNode

---
 .../db/queryengine/plan/planner/LogicalPlanBuilder.java      | 4 +++-
 .../db/queryengine/plan/planner/OperatorTreeGenerator.java   | 5 ++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
index ba463b22bc08..5e614e16e28f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
@@ -621,7 +621,9 @@ private void addSingleDeviceViewNodes(
               context.getQueryId().genPlanNodeId(),
               outputColumnNames,
               deviceName,
-              deviceToMeasurementIndexesMap.get(deviceName));
+              deviceToMeasurementIndexesMap == null
+                  ? null
+                  : deviceToMeasurementIndexesMap.get(deviceName));
 
       // put LIMIT-NODE below of SingleDeviceViewNode if exists value filter
       if (valueFilterLimit > 0) {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
index 0e3c2b47e517..481c84554bf9 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
@@ -991,7 +991,10 @@ public Operator visitSingleDeviceView(
                 node.getPlanNodeId(),
                 SingleDeviceViewOperator.class.getSimpleName());
     Operator child = node.getChild().accept(this, context);
-    List<Integer> deviceColumnIndex = node.getDeviceToMeasurementIndexes();
+    List<Integer> deviceColumnIndex =
+        context.getTemplatedInfo() != null
+            ? context.getTemplatedInfo().getDeviceToMeasurementIndexes()
+            : node.getDeviceToMeasurementIndexes();
     List<TSDataType> outputColumnTypes =
         node.isCacheOutputColumnNames()
             ? getOutputColumnTypes(node, context.getTypeProvider())

From 30b041e6402c76224bfcbbb5e70beb96a8fc4942 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Tue, 28 May 2024 14:55:14 +0800
Subject: [PATCH 26/28] remove useless code

---
 .../db/queryengine/plan/optimization/AggregationPushDown.java  | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index 0068759a2c10..dee29c6a0ef5 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -287,7 +287,6 @@ public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterCon
         boolean isSingleSource = child instanceof SeriesScanSourceNode;
         boolean needCheckAscending = node.getGroupByTimeParameter() == null;
         if (isSingleSource && ((SeriesScanSourceNode) child).getPushDownPredicate() != null) {
-          //          needCheckAscending = false;
           Expression pushDownPredicate = ((SeriesScanSourceNode) child).getPushDownPredicate();
           if (!PredicateUtils.predicateCanPushIntoScan(pushDownPredicate)) {
             // don't push down, simplify the BE side logic
@@ -482,9 +481,7 @@ public PlanNode visitRawDataAggregationTemplateCase(
 
       if (child instanceof FullOuterTimeJoinNode || child instanceof SeriesScanSourceNode) {
         boolean isSingleSource = child instanceof SeriesScanSourceNode;
-        boolean needCheckAscending = node.getGroupByTimeParameter() == null;
         if (isSingleSource && ((SeriesScanSourceNode) child).getPushDownPredicate() != null) {
-          needCheckAscending = false;
           Expression pushDownPredicate = ((SeriesScanSourceNode) child).getPushDownPredicate();
           if (!PredicateUtils.predicateCanPushIntoScan(pushDownPredicate)) {
             // don't push down, simplify the BE side logic

From d5dbbafa9eba8f1fb2195d1ac6f525e8ad334fd1 Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Tue, 28 May 2024 17:00:04 +0800
Subject: [PATCH 27/28] add more having case

---
 ...lignByDeviceWithTemplateAggregationIT.java | 57 +++++++++++++++++++
 .../analyze/TemplatedAggregationAnalyze.java  | 33 +++++++++--
 2 files changed, 86 insertions(+), 4 deletions(-)

diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
index c2a55cda30f3..5ec4566c54ce 100644
--- a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
@@ -404,6 +404,63 @@ public void groupByTest() {
         retArray);
   }
 
+  @Test
+  public void havingTest() {
+    String[] expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),last_value(s2)"};
+    String[] retArray =
+        new String[] {
+          "root.sg1.d1,2,2.2,false,",
+          "root.sg1.d2,1314000000001,13.15,false,",
+          "root.sg1.d3,1314000000002,13.16,false,",
+          "root.sg1.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** where s2=false having avg(s3) > 1 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,2,2.2,false,",
+          "root.sg2.d2,1314000000001,13.15,false,",
+          "root.sg2.d3,1314000000002,13.16,false,",
+          "root.sg2.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s2=false having avg(s3) > 1 align by device;",
+        expectedHeader,
+        retArray);
+
+    retArray =
+        new String[] {
+          "root.sg1.d1,2,2.2,false,",
+          "root.sg1.d2,1314000000001,13.15,false,",
+          "root.sg1.d3,1314000000002,13.16,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** where s2=false having count(s3)+count(s1) > 2 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,2,2.2,false,",
+          "root.sg2.d2,1314000000001,13.15,false,",
+          "root.sg2.d3,1314000000002,13.16,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s2=false having count(s3)+count(s1) > 2 align by device;",
+        expectedHeader,
+        retArray);
+
+    retArray =
+        new String[] {
+          "root.sg2.d2,1314000000001,13.15,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s2=false having count(s3+s1) > 2 align by device;",
+        expectedHeader,
+        retArray);
+  }
+
   @Test
   public void orderByTest() {
     String[] expectedHeader = new String[] {"Time,Device,sum(s3)"};
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index 56a8c5d290aa..2350eb86ffd8 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -25,6 +25,7 @@
 import org.apache.iotdb.db.queryengine.common.schematree.ISchemaTree;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.expression.leaf.ConstantOperand;
+import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimeSeriesOperand;
 import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimestampOperand;
 import org.apache.iotdb.db.queryengine.plan.expression.multi.FunctionExpression;
 import org.apache.iotdb.db.queryengine.plan.statement.component.ResultColumn;
@@ -84,6 +85,7 @@ static boolean canBuildAggregationPlanUseTemplate(
     List<Pair<Expression, String>> outputExpressions = new ArrayList<>();
     boolean valid = analyzeSelect(queryStatement, analysis, outputExpressions, template);
     if (!valid) {
+      analysis.setDeviceTemplate(null);
       return false;
     }
 
@@ -101,7 +103,12 @@ static boolean canBuildAggregationPlanUseTemplate(
       return true;
     }
 
-    analyzeHaving(analysis, queryStatement);
+    valid = analyzeHaving(analysis, queryStatement);
+    if (!valid) {
+      analysis.setDeviceTemplate(null);
+      return false;
+    }
+
     analyzeDeviceToExpressions(analysis);
 
     analyzeDeviceViewOutput(analysis, queryStatement);
@@ -176,7 +183,6 @@ private static boolean analyzeSelect(
         String measurement = selectExpression.getExpressions().get(0).getOutputSymbol();
         //  not support agg(*), agg(s1+1) now
         if (!template.getSchemaMap().containsKey(measurement)) {
-          analysis.setDeviceTemplate(null);
           return false;
         }
 
@@ -197,16 +203,33 @@ private static boolean analyzeSelect(
     return true;
   }
 
-  private static void analyzeHaving(Analysis analysis, QueryStatement queryStatement) {
+  private static boolean analyzeHaving(Analysis analysis, QueryStatement queryStatement) {
     if (!queryStatement.hasHaving()) {
-      return;
+      return true;
     }
 
+    Set<String> measurementSet = new HashSet<>(analysis.getMeasurementList());
     Set<Expression> aggregationExpressions = analysis.getAggregationExpressions();
     Expression havingExpression = queryStatement.getHavingCondition().getPredicate();
     for (Expression aggregationExpression : searchAggregationExpressions(havingExpression)) {
       Expression normalizedAggregationExpression = normalizeExpression(aggregationExpression);
 
+      if (!((normalizedAggregationExpression).getExpressions().get(0)
+          instanceof TimeSeriesOperand)) {
+        return false;
+      }
+
+      String measurement =
+          normalizedAggregationExpression.getExpressions().get(0).getOutputSymbol();
+      if (!measurementSet.contains(measurement)) {
+        // adapt this case: select agg(s1) from xx having agg(s3)
+        measurementSet.add(measurement);
+        analysis.getMeasurementList().add(measurement);
+        analysis
+            .getMeasurementSchemaList()
+            .add(analysis.getDeviceTemplate().getSchema(measurement));
+      }
+
       analyzeExpressionType(analysis, aggregationExpression);
       analyzeExpressionType(analysis, normalizedAggregationExpression);
 
@@ -221,6 +244,8 @@ private static void analyzeHaving(Analysis analysis, QueryStatement queryStateme
               outputType));
     }
     analysis.setHavingExpression(havingExpression);
+
+    return true;
   }
 
   private static void analyzeDeviceToExpressions(Analysis analysis) {

From b6acca4f3a243a413db20f8c3f06dd4cdced30ab Mon Sep 17 00:00:00 2001
From: Beyyes <cgf1993@foxmail.com>
Date: Tue, 28 May 2024 18:38:43 +0800
Subject: [PATCH 28/28] fix smell

---
 .../analyze/TemplatedAggregationAnalyze.java  |  1 +
 .../optimization/AggregationPushDown.java     | 58 +------------------
 .../plan/planner/OperatorTreeGenerator.java   |  3 -
 .../plan/planner/TemplatedLogicalPlan.java    |  4 +-
 4 files changed, 4 insertions(+), 62 deletions(-)

diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
index 2350eb86ffd8..3f6175908128 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -214,6 +214,7 @@ private static boolean analyzeHaving(Analysis analysis, QueryStatement queryStat
     for (Expression aggregationExpression : searchAggregationExpressions(havingExpression)) {
       Expression normalizedAggregationExpression = normalizeExpression(aggregationExpression);
 
+      // not support having agg(s1+s2) temporarily
       if (!((normalizedAggregationExpression).getExpressions().get(0)
           instanceof TimeSeriesOperand)) {
         return false;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index dee29c6a0ef5..994f1a300560 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -66,13 +66,11 @@
 import org.apache.tsfile.write.schema.IMeasurementSchema;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 import static com.google.common.base.Preconditions.checkState;
 import static org.apache.iotdb.db.utils.constant.SqlConstant.COUNT_TIME;
@@ -490,7 +488,7 @@ public PlanNode visitRawDataAggregationTemplateCase(
         }
 
         List<PlanNode> sourceNodeList =
-            newConstructSourceNodeFromTemplateAggregationDescriptors(
+            constructSourceNodeFromTemplateAggregationDescriptors(
                 context
                     .getContext()
                     .getTypeProvider()
@@ -532,60 +530,6 @@ public PlanNode visitRawDataAggregationTemplateCase(
     }
 
     private List<PlanNode> constructSourceNodeFromTemplateAggregationDescriptors(
-        Map<PartialPath, List<AggregationDescriptor>> ascendingAggregations,
-        Map<PartialPath, List<AggregationDescriptor>> descendingAggregations,
-        Map<PartialPath, List<AggregationDescriptor>> countTimeAggregations,
-        Ordering scanOrder,
-        GroupByTimeParameter groupByTimeParameter,
-        RewriterContext context) {
-
-      // keySet of ascendingAggregations is measurement,
-      // valueSet of ascendingAggregations is aggDescriptors such as count(s1), avg(s1)
-
-      List<PlanNode> sourceNodeList = new ArrayList<>();
-      PartialPath devicePath = context.curDevicePath;
-      List<String> measurementList = context.analysis.getMeasurementList();
-      List<IMeasurementSchema> measurementSchemaList = context.analysis.getMeasurementSchemaList();
-      boolean needCheckAscending = groupByTimeParameter == null;
-
-      if (context.analysis.getDeviceTemplate().isDirectAligned()) {
-        AlignedPath alignedPath = new AlignedPath(devicePath);
-        alignedPath.setMeasurementList(measurementList);
-        alignedPath.addSchemas(measurementSchemaList);
-
-        List<AggregationDescriptor> aggregationDescriptors =
-            ascendingAggregations.values().stream()
-                .flatMap(Collection::stream)
-                .collect(Collectors.toList());
-        if (!aggregationDescriptors.isEmpty()) {
-          sourceNodeList.add(
-              createAggregationScanNode(
-                  alignedPath,
-                  aggregationDescriptors,
-                  scanOrder,
-                  groupByTimeParameter,
-                  context,
-                  (byte) 0));
-        }
-
-        if (needCheckAscending && !descendingAggregations.isEmpty()) {
-          aggregationDescriptors =
-              descendingAggregations.values().stream()
-                  .flatMap(Collection::stream)
-                  .collect(Collectors.toList());
-          sourceNodeList.add(
-              createAggregationScanNode(
-                  alignedPath, aggregationDescriptors, scanOrder, null, context, (byte) 1));
-        }
-      } else {
-        throw new IllegalStateException(
-            "Aggregation descriptors with non aligned template are not supported");
-      }
-
-      return sourceNodeList;
-    }
-
-    private List<PlanNode> newConstructSourceNodeFromTemplateAggregationDescriptors(
         List<AggregationDescriptor> ascendingAggregations,
         List<AggregationDescriptor> descendingAggregations,
         Ordering scanOrder,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
index f8a4a85b2dc0..ae1e76658001 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
@@ -1880,11 +1880,8 @@ public Operator visitOffset(OffsetNode node, LocalExecutionPlanContext context)
   @Override
   public Operator visitRawDataAggregation(
       RawDataAggregationNode node, LocalExecutionPlanContext context) {
-    // TODO optimize serialize and deserialize method in template situation
     Map<String, List<InputLocation>> layout;
     if (context.isBuildPlanUseTemplate()) {
-      // in template situation, output columns of ProjectNode is not stored, it's same as its
-      // children
       layout = context.getTemplatedInfo().getFilterLayoutMap();
     } else {
       layout = makeLayout(node);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
index 496053635e5d..fbb10954e2f5 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
@@ -99,7 +99,7 @@ public TemplatedLogicalPlan(
 
     this.whereExpression = analysis.getWhereExpression();
 
-    // for align by device query with template, most used variables are same
+    // for align by device query with template, store common variables for once
     if (queryStatement.isAggregationQuery()) {
       initAggQueryCommonVariables();
     } else {
@@ -144,7 +144,7 @@ private void initAggQueryCommonVariables() {
     }
 
     List<Integer> deviceToMeasurementIndexes =
-        new ArrayList<>(analysis.getSelectExpressions().size() - 1);
+        new ArrayList<>(analysis.getAggregationExpressions().size());
     for (int i = 1; i <= analysis.getAggregationExpressions().size(); i++) {
       deviceToMeasurementIndexes.add(i);
     }