You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ca...@apache.org on 2024/10/13 03:09:18 UTC

(iotdb) branch master updated: Add aggregation table scan impl for table model

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

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


The following commit(s) were added to refs/heads/master by this push:
     new 207f90a3324 Add aggregation table scan impl for table model
207f90a3324 is described below

commit 207f90a3324a69220caded41eaa9e824cc4e1cd4
Author: Beyyes <cg...@foxmail.com>
AuthorDate: Sun Oct 13 11:09:12 2024 +0800

    Add aggregation table scan impl for table model
---
 .../db/it/IoTDBMultiIDsWithAttributesTableIT.java  | 197 +++++-
 .../protocol/thrift/impl/ClientRPCServiceImpl.java |   6 +-
 .../{Aggregator.java => TreeAggregator.java}       |   8 +-
 .../slidingwindow/SlidingWindowAggregator.java     |   4 +-
 .../execution/operator/AggregationUtil.java        |  23 +-
 .../operator/process/AggregationOperator.java      |  12 +-
 .../process/RawDataAggregationOperator.java        |   8 +-
 .../process/SingleInputAggregationOperator.java    |   6 +-
 .../process/SlidingWindowAggregationOperator.java  |  10 +-
 .../operator/process/TagAggregationOperator.java   |  21 +-
 .../operator/process/last/LastQueryUtil.java       |  18 +-
 .../AbstractSeriesAggregationScanOperator.java     |  14 +-
 .../AlignedSeriesAggregationScanOperator.java      |   6 +-
 .../source/SeriesAggregationScanOperator.java      |   6 +-
 .../TableAggregationTableScanOperator.java         | 661 +++++++++++++++++++++
 .../source/relational/TableScanOperator.java       |   4 -
 .../relational/aggregation/AccumulatorFactory.java |   8 +-
 .../aggregation/AggregationOperator.java           |  10 +-
 .../relational/aggregation/AvgAccumulator.java     |  49 +-
 .../relational/aggregation/CountAccumulator.java   |  27 +-
 .../{Accumulator.java => TableAccumulator.java}    |  17 +-
 .../{Aggregator.java => TableAggregator.java}      |  19 +-
 .../operator/window/ConditionWindowManager.java    |   6 +-
 .../operator/window/CountWindowManager.java        |   6 +-
 .../execution/operator/window/IWindowManager.java  |  15 +-
 .../operator/window/SessionWindowManager.java      |   6 +-
 .../operator/window/TimeWindowManager.java         |   6 +-
 .../operator/window/VariationWindowManager.java    |   6 +-
 .../plan/planner/OperatorTreeGenerator.java        |  36 +-
 .../plan/planner/TableOperatorGenerator.java       | 213 ++++++-
 .../plan/planner/plan/node/PlanGraphPrinter.java   |   4 +-
 .../plan/relational/function/BoundSignature.java   |   4 -
 .../metadata/TableBuiltinAggregationFunction.java  |   1 +
 .../relational/metadata/TableMetadataImpl.java     |   1 +
 .../distribute/TableDistributedPlanGenerator.java  |   1 +
 .../TableModelTypeProviderExtractor.java           |  16 +-
 .../planner/node/AggregationTableScanNode.java     |  90 ++-
 .../optimizations/PushPredicateIntoTableScan.java  |  23 +-
 .../relational/planner/optimizations/Util.java     |  23 +-
 .../iotdb/db/utils/constant/SqlConstant.java       |   5 +-
 .../operator/AggregationOperatorTest.java          |  10 +-
 .../AlignedSeriesAggregationScanOperatorTest.java  |  73 +--
 .../operator/HorizontallyConcatOperatorTest.java   |   6 +-
 .../execution/operator/LastQueryOperatorTest.java  |  10 +-
 .../operator/LastQueryTreeSortOperatorTest.java    |  10 +-
 .../execution/operator/OperatorMemoryTest.java     |  18 +-
 .../operator/RawDataAggregationOperatorTest.java   |   6 +-
 .../SeriesAggregationScanOperatorTest.java         |  68 +--
 .../SlidingWindowAggregationOperatorTest.java      |   9 +-
 .../operator/UpdateLastCacheOperatorTest.java      |  10 +-
 50 files changed, 1491 insertions(+), 325 deletions(-)

diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBMultiIDsWithAttributesTableIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBMultiIDsWithAttributesTableIT.java
index 490bb17f773..8933d848159 100644
--- a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBMultiIDsWithAttributesTableIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBMultiIDsWithAttributesTableIT.java
@@ -86,6 +86,33 @@ public class IoTDBMultiIDsWithAttributesTableIT {
         "insert into table0(device,level,time,num,bigNum,floatNum,str,bool,date) values('d2','l5',51536000000,15,3147483648,235.213,'watermelon',TRUE,'2023-01-01')"
       };
 
+  private static final String[] sql3 =
+      new String[] {
+        "CREATE TABLE table1 (device string id, level string id, attr1 string attribute, attr2 string attribute, num int32 measurement, bigNum int64 measurement, "
+            + "floatNum double measurement, str TEXT measurement, bool BOOLEAN measurement, date DATE measurement, blob BLOB measurement)",
+        "insert into table1(device, level, attr1, attr2, time, num, bigNum, floatNum, str, bool, date, blob) "
+            + "values('d1', 'l1', 'c', 'd', 0, 3, 2947483648,231.2121, 'coconut', FALSE, '2023-01-01', X'100DCD62')",
+        "insert into table1(device, level, attr1, attr2, time, num, bigNum, floatNum, str, bool, blob) "
+            + "values('d1', 'l2', 'y', 'z', 20, 2, 2147483648,434.12, 'pineapple', TRUE, X'101DCD62')",
+        "insert into table1(device, level, attr1, attr2, time, num, bigNum, floatNum, str, bool, blob) "
+            + "values('d1', 'l3', 't', 'a', 40, 1, 2247483648,12.123, 'apricot', TRUE, null)",
+        "insert into table1(device, level, time, num, bigNum, floatNum, str, bool, blob) "
+            + "values('d1', 'l4', 80, 9, 2147483646, 43.12, 'apple', FALSE, X'104DCD62')",
+        "insert into table1(device, level, time, num, bigNum, floatNum, str, bool, date, blob) "
+            + "values('d1', 'l5', 100, 8, 2147483964, 4654.231, 'papaya', TRUE, '2023-05-01', null)",
+        "flush",
+        "insert into table1(device, level, time, num, bigNum, floatNum, str, bool, blob) "
+            + "values('d1', 'l1', 31536000000, 6, 2147483650, 1231.21, 'banana', TRUE, X'106DCD62')",
+        "insert into table1(device, time, num, bigNum, floatNum, str, bool, blob) "
+            + "values('d999', 31536000000, 6, 2147483650, 1231.21, 'banana', TRUE, X'107DCD62')",
+        "insert into table1(level, time, num, bigNum, floatNum, str, bool, date, blob) "
+            + "values('l999', 31536000000, 6, 2147483650, 1231.21, 'banana', TRUE, '2023-10-01', X'108DCD62')",
+      };
+
+  String[] expectedHeader;
+
+  String[] retArray;
+
   @BeforeClass
   public static void setUp() throws Exception {
     EnvFactory.getEnv().getConfig().getDataNodeCommonConfig().setSortBufferSize(1024 * 1024L);
@@ -113,6 +140,9 @@ public class IoTDBMultiIDsWithAttributesTableIT {
       for (String sql : sql2) {
         statement.execute(sql);
       }
+      for (String sql : sql3) {
+        statement.execute(sql);
+      }
     } catch (Exception e) {
       e.printStackTrace();
       fail(e.getMessage());
@@ -431,7 +461,151 @@ public class IoTDBMultiIDsWithAttributesTableIT {
         DATABASE_NAME);
   }
 
-  // ========== Join Test =========
+  // ============================ Aggregation Test ===========================
+  @Test
+  public void aggregationTest() {
+    String[] expectedHeader =
+        new String[] {
+          "count_num",
+          "count_star",
+          "avg_num",
+          "count_num",
+          "count_attr2",
+          "avg_num",
+          "count_device",
+          "count_attr1",
+          "count_device",
+          "avg_floatnum",
+          "count_date",
+          "count_time",
+          "count_star"
+        };
+    String[] retArray =
+        new String[] {
+          "30,30,8.0,30,12,8.0,30,15,30,529.0,2,30,30,",
+        };
+    tableResultSetEqualTest(
+        "select count(num) as count_num, count(*) as count_star, avg(num) as avg_num, count(num) as count_num,\n"
+            + "count(attr2) as count_attr2, avg(num) as avg_num, count(device) as count_device,\n"
+            + "count(attr1) as count_attr1, count(device) as count_device, \n"
+            + "round(avg(floatnum)) as avg_floatnum, count(date) as count_date, "
+            + "count(time) as count_time, count(*) as count_star "
+            + "from table0",
+        expectedHeader,
+        retArray,
+        DATABASE_NAME);
+
+    retArray =
+        new String[] {
+          "8,8,5.5,8,3,5.5,8,4,8,1341.0,0,8,8,",
+        };
+    tableResultSetEqualTest(
+        "select count(num) as count_num, count(*) as count_star, avg(num) as avg_num, count(num) as count_num,\n"
+            + "count(attr2) as count_attr2, avg(num) as avg_num, count(device) as count_device,\n"
+            + "count(attr1) as count_attr1, count(device) as count_device, \n"
+            + "round(avg(floatnum)) as avg_floatnum, count(date) as count_date, "
+            + "count(time) as count_time, count(*) as count_star "
+            + "from table0 "
+            + "where time<200 and num>1 ",
+        expectedHeader,
+        retArray,
+        DATABASE_NAME);
+
+    // ID has null value
+    expectedHeader =
+        new String[] {
+          "count_num",
+          "avg_num",
+          "count_num",
+          "count_attr2",
+          "avg_num",
+          "count_device",
+          "count_attr1",
+          "count_device",
+          "avg_floatnum",
+          "count_date",
+          "count_level",
+          "count_time",
+          "count_star"
+        };
+    retArray =
+        new String[] {
+          "8,5.125,8,4,5.125,7,4,7,1134.0,3,7,8,8,",
+        };
+    tableResultSetEqualTest(
+        "select count(num) as count_num, avg(num) as avg_num, count(num) as count_num,\n"
+            + "count(attr2) as count_attr2, avg(num) as avg_num, count(device) as count_device,\n"
+            + "count(attr1) as count_attr1, count(device) as count_device, \n"
+            + "round(avg(floatnum)) as avg_floatnum, count(date) as count_date, count(level) as count_level,"
+            + "count(time) as count_time, count(*) as count_star "
+            + "from table1",
+        expectedHeader,
+        retArray,
+        DATABASE_NAME);
+
+    // count star with subquery
+    // TODO(beyyes) add first/last blob type test
+  }
+
+  @Test
+  public void globalAggregationTest() {
+    String[] expectedHeader = new String[] {"_col0"};
+    String[] retArray = new String[] {"30,"};
+
+    String sql = "SELECT count(num+1) from table0";
+    tableResultSetEqualTest(sql, expectedHeader, retArray, DATABASE_NAME);
+  }
+
+  @Test
+  public void countStarTest() {
+    expectedHeader = new String[] {"_col0", "_col1"};
+    retArray = new String[] {"1,1,"};
+    String sql = "select count(*),count(t1) from (select avg(num+1) as t1 from table0)";
+    tableResultSetEqualTest(sql, expectedHeader, retArray, DATABASE_NAME);
+
+    expectedHeader = new String[] {"count_star"};
+    retArray =
+        new String[] {
+          "30,",
+        };
+    tableResultSetEqualTest(
+        "select count(*) as count_star from table0", expectedHeader, retArray, DATABASE_NAME);
+
+    retArray =
+        new String[] {
+          "1,",
+        };
+    tableResultSetEqualTest(
+        "select count(*) as count_star from (select count(*) from table0)",
+        expectedHeader,
+        retArray,
+        DATABASE_NAME);
+
+    retArray =
+        new String[] {
+          "1,",
+        };
+    tableResultSetEqualTest(
+        "select count(*) as count_star from (select count(*), avg(num) from table0)",
+        expectedHeader,
+        retArray,
+        DATABASE_NAME);
+
+    expectedHeader = new String[] {"sum"};
+    retArray =
+        new String[] {
+          "38.0,",
+        };
+    tableResultSetEqualTest(
+        "select count_star + avg_num as sum from (select count(*) as count_star, avg(num) as avg_num from table0)",
+        expectedHeader,
+        retArray,
+        DATABASE_NAME);
+
+    // TODO select count(*),count(t1) from (select avg(num+1) as t1 from table0) where time < 0
+  }
+
+  // ============================ Join Test ===========================
   // no filter
   @Test
   public void innerJoinTest1() {
@@ -714,25 +888,4 @@ public class IoTDBMultiIDsWithAttributesTableIT {
             + "ORDER BY time, t1.device, t2.device";
     tableResultSetEqualTest(sql, expectedHeader, retArray, DATABASE_NAME);
   }
-
-  // ========== Aggregation Test =========
-  @Test
-  public void globalAggregationTest() {
-    String[] expectedHeader = new String[] {"_col0"};
-    String[] retArray = new String[] {"30,"};
-
-    String sql = "SELECT count(num+1) from table0";
-    tableResultSetEqualTest(sql, expectedHeader, retArray, DATABASE_NAME);
-  }
-
-  @Test
-  public void countStarTest() {
-    String[] expectedHeader = new String[] {"_col0", "_col1"};
-    String[] retArray = new String[] {"1,1,"};
-
-    String sql = "select count(*),count(t1) from (select avg(num+1) as t1 from table0)";
-    tableResultSetEqualTest(sql, expectedHeader, retArray, DATABASE_NAME);
-
-    // TODO select count(*),count(t1) from (select avg(num+1) as t1 from table0) where time < 0
-  }
 }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java
index 4462ad66fce..18363ce11e7 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java
@@ -63,7 +63,7 @@ import org.apache.iotdb.db.queryengine.common.header.ColumnHeader;
 import org.apache.iotdb.db.queryengine.common.header.DatasetHeader;
 import org.apache.iotdb.db.queryengine.common.header.DatasetHeaderFactory;
 import org.apache.iotdb.db.queryengine.execution.aggregation.AccumulatorFactory;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.driver.DriverContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceManager;
@@ -752,8 +752,8 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
     scanOptionsBuilder.withGlobalTimeFilter(timeFilter);
 
     String aggregationName = SchemaUtils.getBuiltinAggregationName(aggregationType);
-    Aggregator aggregator =
-        new Aggregator(
+    TreeAggregator aggregator =
+        new TreeAggregator(
             AccumulatorFactory.createAccumulator(
                 aggregationName,
                 aggregationType,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/aggregation/Aggregator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/aggregation/TreeAggregator.java
similarity index 96%
rename from iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/aggregation/Aggregator.java
rename to iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/aggregation/TreeAggregator.java
index 6992d80b53f..30ce92091d8 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/aggregation/Aggregator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/aggregation/TreeAggregator.java
@@ -37,17 +37,17 @@ import static com.google.common.base.Preconditions.checkArgument;
 import static org.apache.iotdb.db.queryengine.metric.QueryExecutionMetricSet.AGGREGATION_FROM_RAW_DATA;
 import static org.apache.iotdb.db.queryengine.metric.QueryExecutionMetricSet.AGGREGATION_FROM_STATISTICS;
 
-public class Aggregator {
+public class TreeAggregator {
 
   protected final Accumulator accumulator;
   // In some intermediate result input, inputLocation[] should include two columns
   protected List<InputLocation[]> inputLocationList;
   protected final AggregationStep step;
-  protected static final QueryExecutionMetricSet QUERY_EXECUTION_METRICS =
+  public static final QueryExecutionMetricSet QUERY_EXECUTION_METRICS =
       QueryExecutionMetricSet.getInstance();
 
   // Used for SeriesAggregateScanOperator
-  public Aggregator(Accumulator accumulator, AggregationStep step) {
+  public TreeAggregator(Accumulator accumulator, AggregationStep step) {
     this.accumulator = accumulator;
     this.step = step;
     this.inputLocationList =
@@ -55,7 +55,7 @@ public class Aggregator {
   }
 
   // Used for AggregateOperator, AlignedSeriesAggregateScanOperator
-  public Aggregator(
+  public TreeAggregator(
       Accumulator accumulator, AggregationStep step, List<InputLocation[]> inputLocationList) {
     this.accumulator = accumulator;
     this.step = step;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/aggregation/slidingwindow/SlidingWindowAggregator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/aggregation/slidingwindow/SlidingWindowAggregator.java
index 3421487700e..adc179f77ec 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/aggregation/slidingwindow/SlidingWindowAggregator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/aggregation/slidingwindow/SlidingWindowAggregator.java
@@ -20,7 +20,7 @@
 package org.apache.iotdb.db.queryengine.execution.aggregation.slidingwindow;
 
 import org.apache.iotdb.db.queryengine.execution.aggregation.Accumulator;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationStep;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.InputLocation;
 
@@ -37,7 +37,7 @@ import java.util.stream.Collectors;
 
 import static com.google.common.base.Preconditions.checkArgument;
 
-public abstract class SlidingWindowAggregator extends Aggregator {
+public abstract class SlidingWindowAggregator extends TreeAggregator {
 
   // cached partial aggregation result of pre-aggregate windows
   protected Deque<PartialAggregationResult> deque;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/AggregationUtil.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/AggregationUtil.java
index cbf30889650..6bcfa9a3169 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/AggregationUtil.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/AggregationUtil.java
@@ -20,7 +20,7 @@
 package org.apache.iotdb.db.queryengine.execution.operator;
 
 import org.apache.iotdb.commons.udf.builtin.BuiltinAggregationFunction;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.SingleTimeWindowIterator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.TimeRangeIteratorFactory;
@@ -96,7 +96,7 @@ public class AggregationUtil {
    */
   public static Pair<Boolean, TsBlock> calculateAggregationFromRawData(
       TsBlock inputTsBlock,
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       TimeRange curTimeRange,
       boolean ascending) {
     if (inputTsBlock == null || inputTsBlock.isEmpty()) {
@@ -124,8 +124,8 @@ public class AggregationUtil {
         isAllAggregatorsHasFinalResult(aggregators) || isTsBlockOutOfBound, inputTsBlock);
   }
 
-  private static TsBlock process(
-      TsBlock inputTsBlock, TimeRange curTimeRange, List<Aggregator> aggregators) {
+  public static TsBlock process(
+      TsBlock inputTsBlock, TimeRange curTimeRange, List<TreeAggregator> aggregators) {
     // Get the row which need to be processed by aggregator
     IWindow curWindow = new TimeWindow(curTimeRange);
     Column timeColumn = inputTsBlock.getTimeColumn();
@@ -138,7 +138,7 @@ public class AggregationUtil {
     }
 
     TsBlock inputRegion = inputTsBlock.getRegion(0, lastIndexToProcess + 1);
-    for (Aggregator aggregator : aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       // current agg method has been calculated
       if (aggregator.hasFinalResult()) {
         continue;
@@ -156,7 +156,7 @@ public class AggregationUtil {
   /** Append a row of aggregation results to the result tsBlock. */
   public static void appendAggregationResult(
       TsBlockBuilder tsBlockBuilder,
-      List<? extends Aggregator> aggregators,
+      List<? extends TreeAggregator> aggregators,
       long outputTime,
       long endTime) {
     TimeColumnBuilder timeColumnBuilder = tsBlockBuilder.getTimeColumnBuilder();
@@ -168,7 +168,7 @@ public class AggregationUtil {
       columnBuilders[columnIndex].writeLong(endTime);
       columnIndex++;
     }
-    for (Aggregator aggregator : aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       ColumnBuilder[] columnBuilder = new ColumnBuilder[aggregator.getOutputType().length];
       columnBuilder[0] = columnBuilders[columnIndex++];
       if (columnBuilder.length > 1) {
@@ -180,7 +180,7 @@ public class AggregationUtil {
   }
 
   public static void appendAggregationResult(
-      TsBlockBuilder tsBlockBuilder, List<? extends Aggregator> aggregators, long outputTime) {
+      TsBlockBuilder tsBlockBuilder, List<? extends TreeAggregator> aggregators, long outputTime) {
     appendAggregationResult(tsBlockBuilder, aggregators, outputTime, INVALID_END_TIME);
   }
 
@@ -198,8 +198,8 @@ public class AggregationUtil {
             && tsBlock.getStartTime() >= curTimeRange.getMin());
   }
 
-  public static boolean isAllAggregatorsHasFinalResult(List<Aggregator> aggregators) {
-    for (Aggregator aggregator : aggregators) {
+  public static boolean isAllAggregatorsHasFinalResult(List<TreeAggregator> aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       if (!aggregator.hasFinalResult()) {
         return false;
       }
@@ -230,7 +230,8 @@ public class AggregationUtil {
             * timeValueColumnsSizePerLine);
   }
 
-  public static long calculateMaxAggregationResultSizeForLastQuery(List<Aggregator> aggregators) {
+  public static long calculateMaxAggregationResultSizeForLastQuery(
+      List<TreeAggregator> aggregators) {
     long timeValueColumnsSizePerLine = TimeColumn.SIZE_IN_BYTES_PER_POSITION;
     List<TSDataType> outPutDataTypes =
         aggregators.stream()
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/AggregationOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/AggregationOperator.java
index ff1de243b27..1e933f4b415 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/AggregationOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/AggregationOperator.java
@@ -20,7 +20,7 @@
 package org.apache.iotdb.db.queryengine.execution.operator.process;
 
 import org.apache.iotdb.db.queryengine.execution.MemoryEstimationHelper;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
 import org.apache.iotdb.db.queryengine.execution.operator.Operator;
 import org.apache.iotdb.db.queryengine.execution.operator.OperatorContext;
@@ -52,7 +52,7 @@ public class AggregationOperator extends AbstractConsumeAllOperator {
   // Current interval of aggregation window [curStartTime, curEndTime)
   private TimeRange curTimeRange;
 
-  private final List<Aggregator> aggregators;
+  private final List<TreeAggregator> aggregators;
 
   // Using for building result tsBlock
   private final TsBlockBuilder resultTsBlockBuilder;
@@ -63,7 +63,7 @@ public class AggregationOperator extends AbstractConsumeAllOperator {
 
   public AggregationOperator(
       OperatorContext operatorContext,
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       ITimeRangeIterator timeRangeIterator,
       List<Operator> children,
       boolean outputEndTime,
@@ -75,7 +75,7 @@ public class AggregationOperator extends AbstractConsumeAllOperator {
     if (outputEndTime) {
       dataTypes.add(TSDataType.INT64);
     }
-    for (Aggregator aggregator : aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       dataTypes.addAll(Arrays.asList(aggregator.getOutputType()));
     }
     this.resultTsBlockBuilder = new TsBlockBuilder(dataTypes);
@@ -128,7 +128,7 @@ public class AggregationOperator extends AbstractConsumeAllOperator {
         curTimeRange = timeRangeIterator.nextTimeRange();
 
         // Clear previous aggregation result
-        for (Aggregator aggregator : aggregators) {
+        for (TreeAggregator aggregator : aggregators) {
           aggregator.reset();
         }
       }
@@ -153,7 +153,7 @@ public class AggregationOperator extends AbstractConsumeAllOperator {
 
   private void calculateNextAggregationResult() {
     // Consume current input tsBlocks
-    for (Aggregator aggregator : aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       aggregator.processTsBlocks(inputTsBlocks);
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/RawDataAggregationOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/RawDataAggregationOperator.java
index 69f67503cc4..e177834b8f5 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/RawDataAggregationOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/RawDataAggregationOperator.java
@@ -20,7 +20,7 @@
 package org.apache.iotdb.db.queryengine.execution.operator.process;
 
 import org.apache.iotdb.db.queryengine.execution.MemoryEstimationHelper;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
 import org.apache.iotdb.db.queryengine.execution.operator.Operator;
 import org.apache.iotdb.db.queryengine.execution.operator.OperatorContext;
@@ -69,7 +69,7 @@ public class RawDataAggregationOperator extends SingleInputAggregationOperator {
 
   public RawDataAggregationOperator(
       OperatorContext operatorContext,
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       ITimeRangeIterator timeRangeIterator,
       Operator child,
       boolean ascending,
@@ -195,7 +195,7 @@ public class RawDataAggregationOperator extends SingleInputAggregationOperator {
       }
 
       TsBlock inputRegion = inputTsBlock.getRegion(0, lastIndexToProcess + 1);
-      for (Aggregator aggregator : aggregators) {
+      for (TreeAggregator aggregator : aggregators) {
         // Current agg method has been calculated
         if (aggregator.hasFinalResult()) {
           continue;
@@ -255,7 +255,7 @@ public class RawDataAggregationOperator extends SingleInputAggregationOperator {
 
   private void initWindowAndAggregators() {
     windowManager.initCurWindow();
-    for (Aggregator aggregator : aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       aggregator.reset();
     }
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/SingleInputAggregationOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/SingleInputAggregationOperator.java
index 50fdff2eee3..1f36586653e 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/SingleInputAggregationOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/SingleInputAggregationOperator.java
@@ -19,7 +19,7 @@
 
 package org.apache.iotdb.db.queryengine.execution.operator.process;
 
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.operator.Operator;
 import org.apache.iotdb.db.queryengine.execution.operator.OperatorContext;
 
@@ -39,7 +39,7 @@ public abstract class SingleInputAggregationOperator implements ProcessOperator
   protected TsBlock inputTsBlock;
   protected boolean canCallNext;
 
-  protected final List<Aggregator> aggregators;
+  protected final List<TreeAggregator> aggregators;
 
   // using for building result tsBlock
   protected TsBlockBuilder resultTsBlockBuilder;
@@ -49,7 +49,7 @@ public abstract class SingleInputAggregationOperator implements ProcessOperator
 
   protected SingleInputAggregationOperator(
       OperatorContext operatorContext,
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       Operator child,
       boolean ascending,
       long maxReturnSize) {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/SlidingWindowAggregationOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/SlidingWindowAggregationOperator.java
index 9a1de9522af..ee460aa5677 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/SlidingWindowAggregationOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/SlidingWindowAggregationOperator.java
@@ -20,7 +20,7 @@
 package org.apache.iotdb.db.queryengine.execution.operator.process;
 
 import org.apache.iotdb.db.queryengine.execution.MemoryEstimationHelper;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.slidingwindow.SlidingWindowAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
 import org.apache.iotdb.db.queryengine.execution.operator.Operator;
@@ -55,7 +55,7 @@ public class SlidingWindowAggregationOperator extends SingleInputAggregationOper
 
   public SlidingWindowAggregationOperator(
       OperatorContext operatorContext,
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       ITimeRangeIterator timeRangeIterator,
       Operator child,
       boolean ascending,
@@ -71,7 +71,7 @@ public class SlidingWindowAggregationOperator extends SingleInputAggregationOper
     if (outputEndTime) {
       dataTypes.add(TSDataType.INT64);
     }
-    for (Aggregator aggregator : aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       dataTypes.addAll(Arrays.asList(aggregator.getOutputType()));
     }
     this.resultTsBlockBuilder = new TsBlockBuilder(dataTypes);
@@ -94,7 +94,7 @@ public class SlidingWindowAggregationOperator extends SingleInputAggregationOper
       curTimeRange = timeRangeIterator.nextTimeRange();
 
       // Clear previous aggregation result
-      for (Aggregator aggregator : aggregators) {
+      for (TreeAggregator aggregator : aggregators) {
         ((SlidingWindowAggregator) aggregator).updateTimeRange(curTimeRange);
       }
     }
@@ -142,7 +142,7 @@ public class SlidingWindowAggregationOperator extends SingleInputAggregationOper
       return;
     }
 
-    for (Aggregator aggregator : aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       ((SlidingWindowAggregator) aggregator).processTsBlock(inputTsBlock);
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/TagAggregationOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/TagAggregationOperator.java
index d7399fb4554..e1869013365 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/TagAggregationOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/TagAggregationOperator.java
@@ -20,7 +20,7 @@
 package org.apache.iotdb.db.queryengine.execution.operator.process;
 
 import org.apache.iotdb.db.queryengine.execution.MemoryEstimationHelper;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.operator.Operator;
 import org.apache.iotdb.db.queryengine.execution.operator.OperatorContext;
 
@@ -44,7 +44,7 @@ public class TagAggregationOperator extends AbstractConsumeAllOperator {
   private static final long INSTANCE_SIZE =
       RamUsageEstimator.shallowSizeOfInstance(TagAggregationOperator.class);
   private final List<List<String>> groups;
-  private final List<List<Aggregator>> groupedAggregators;
+  private final List<List<TreeAggregator>> groupedAggregators;
 
   // These fields record the to be consumed index of each tsBlock.
   private final int[] consumedIndices;
@@ -55,7 +55,7 @@ public class TagAggregationOperator extends AbstractConsumeAllOperator {
   public TagAggregationOperator(
       OperatorContext operatorContext,
       List<List<String>> groups,
-      List<List<Aggregator>> groupedAggregators,
+      List<List<TreeAggregator>> groupedAggregators,
       List<Operator> children,
       long maxReturnSize) {
     super(operatorContext, children);
@@ -68,8 +68,8 @@ public class TagAggregationOperator extends AbstractConsumeAllOperator {
     for (int outputColumnIdx = 0;
         outputColumnIdx < groupedAggregators.get(0).size();
         outputColumnIdx++) {
-      for (List<Aggregator> aggregators : groupedAggregators) {
-        Aggregator aggregator = aggregators.get(outputColumnIdx);
+      for (List<TreeAggregator> aggregators : groupedAggregators) {
+        TreeAggregator aggregator = aggregators.get(outputColumnIdx);
         if (aggregator != null) {
           actualOutputColumnTypes.addAll(Arrays.asList(aggregator.getOutputType()));
           break;
@@ -109,7 +109,7 @@ public class TagAggregationOperator extends AbstractConsumeAllOperator {
       rowBlocks[i] = inputTsBlocks[i].getRegion(consumedIndices[i], 1);
     }
     for (int groupIdx = 0; groupIdx < groups.size(); groupIdx++) {
-      List<Aggregator> aggregators = groupedAggregators.get(groupIdx);
+      List<TreeAggregator> aggregators = groupedAggregators.get(groupIdx);
       aggregate(aggregators, rowBlocks);
       List<String> group = groups.get(groupIdx);
       appendOneRow(rowBlocks, group, aggregators);
@@ -121,8 +121,8 @@ public class TagAggregationOperator extends AbstractConsumeAllOperator {
     }
   }
 
-  private void aggregate(List<Aggregator> aggregators, TsBlock[] rowBlocks) {
-    for (Aggregator aggregator : aggregators) {
+  private void aggregate(List<TreeAggregator> aggregators, TsBlock[] rowBlocks) {
+    for (TreeAggregator aggregator : aggregators) {
       if (aggregator == null) {
         continue;
       }
@@ -131,7 +131,8 @@ public class TagAggregationOperator extends AbstractConsumeAllOperator {
     }
   }
 
-  private void appendOneRow(TsBlock[] rowBlocks, List<String> group, List<Aggregator> aggregators) {
+  private void appendOneRow(
+      TsBlock[] rowBlocks, List<String> group, List<TreeAggregator> aggregators) {
     TimeColumnBuilder timeColumnBuilder = tsBlockBuilder.getTimeColumnBuilder();
     timeColumnBuilder.writeLong(rowBlocks[0].getStartTime());
     ColumnBuilder[] columnBuilders = tsBlockBuilder.getValueColumnBuilders();
@@ -144,7 +145,7 @@ public class TagAggregationOperator extends AbstractConsumeAllOperator {
       }
     }
     for (int i = 0; i < aggregators.size(); i++) {
-      Aggregator aggregator = aggregators.get(i);
+      TreeAggregator aggregator = aggregators.get(i);
       ColumnBuilder columnBuilder = columnBuilders[i + group.size()];
       if (aggregator == null) {
         columnBuilder.appendNull();
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/last/LastQueryUtil.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/last/LastQueryUtil.java
index 98525791f6d..d68ae9b9e8b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/last/LastQueryUtil.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/last/LastQueryUtil.java
@@ -20,9 +20,9 @@
 package org.apache.iotdb.db.queryengine.execution.operator.process.last;
 
 import org.apache.iotdb.commons.conf.CommonDescriptor;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.LastValueDescAccumulator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.MaxTimeDescAccumulator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationStep;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.InputLocation;
 
@@ -130,33 +130,33 @@ public class LastQueryUtil {
     return filter == null || filter.satisfy(tvPair.getTimestamp(), tvPair.getValue().getValue());
   }
 
-  public static List<Aggregator> createAggregators(TSDataType dataType) {
+  public static List<TreeAggregator> createAggregators(TSDataType dataType) {
     // max_time, last_value
-    List<Aggregator> aggregators = new ArrayList<>(2);
+    List<TreeAggregator> aggregators = new ArrayList<>(2);
     aggregators.add(
-        new Aggregator(
+        new TreeAggregator(
             new MaxTimeDescAccumulator(),
             AggregationStep.SINGLE,
             Collections.singletonList(new InputLocation[] {new InputLocation(0, 0)})));
     aggregators.add(
-        new Aggregator(
+        new TreeAggregator(
             new LastValueDescAccumulator(dataType),
             AggregationStep.SINGLE,
             Collections.singletonList(new InputLocation[] {new InputLocation(0, 0)})));
     return aggregators;
   }
 
-  public static List<Aggregator> createAggregators(TSDataType dataType, int valueColumnIndex) {
+  public static List<TreeAggregator> createAggregators(TSDataType dataType, int valueColumnIndex) {
     // max_time, last_value
-    List<Aggregator> aggregators = new ArrayList<>(2);
+    List<TreeAggregator> aggregators = new ArrayList<>(2);
     aggregators.add(
-        new Aggregator(
+        new TreeAggregator(
             new MaxTimeDescAccumulator(),
             AggregationStep.SINGLE,
             Collections.singletonList(
                 new InputLocation[] {new InputLocation(0, valueColumnIndex)})));
     aggregators.add(
-        new Aggregator(
+        new TreeAggregator(
             new LastValueDescAccumulator(dataType),
             AggregationStep.SINGLE,
             Collections.singletonList(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AbstractSeriesAggregationScanOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AbstractSeriesAggregationScanOperator.java
index d8ca5829403..17ef8197a1f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AbstractSeriesAggregationScanOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AbstractSeriesAggregationScanOperator.java
@@ -19,7 +19,7 @@
 
 package org.apache.iotdb.db.queryengine.execution.operator.source;
 
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
 import org.apache.iotdb.db.queryengine.execution.operator.OperatorContext;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeId;
@@ -57,7 +57,7 @@ public abstract class AbstractSeriesAggregationScanOperator extends AbstractData
 
   // We still think aggregator in SeriesAggregateScanOperator is a inputRaw step.
   // But in facing of statistics, it will invoke another method processStatistics()
-  protected final List<Aggregator> aggregators;
+  protected final List<TreeAggregator> aggregators;
 
   protected boolean finished = false;
 
@@ -69,7 +69,7 @@ public abstract class AbstractSeriesAggregationScanOperator extends AbstractData
   private long leftRuntimeOfOneNextCall;
 
   /** Some special data types(like BLOB) cannot use statistics. */
-  private final boolean canUseStatistics;
+  protected final boolean canUseStatistics;
 
   @SuppressWarnings("squid:S107")
   protected AbstractSeriesAggregationScanOperator(
@@ -77,7 +77,7 @@ public abstract class AbstractSeriesAggregationScanOperator extends AbstractData
       OperatorContext context,
       SeriesScanUtil seriesScanUtil,
       int subSensorSize,
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       ITimeRangeIterator timeRangeIterator,
       boolean ascending,
       boolean outputEndTime,
@@ -134,7 +134,7 @@ public abstract class AbstractSeriesAggregationScanOperator extends AbstractData
         // move to the next time window
         curTimeRange = timeRangeIterator.nextTimeRange();
         // clear previous aggregation result
-        for (Aggregator aggregator : aggregators) {
+        for (TreeAggregator aggregator : aggregators) {
           aggregator.reset();
         }
       }
@@ -230,7 +230,7 @@ public abstract class AbstractSeriesAggregationScanOperator extends AbstractData
   }
 
   protected void calcFromStatistics(Statistics timeStatistics, Statistics[] valueStatistics) {
-    for (Aggregator aggregator : aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       if (aggregator.hasFinalResult()) {
         continue;
       }
@@ -377,7 +377,7 @@ public abstract class AbstractSeriesAggregationScanOperator extends AbstractData
     if (outputEndTime) {
       dataTypes.add(TSDataType.INT64);
     }
-    for (Aggregator aggregator : aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       dataTypes.addAll(Arrays.asList(aggregator.getOutputType()));
     }
     return dataTypes;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesAggregationScanOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesAggregationScanOperator.java
index e513e77e6f1..67ebcfe3d20 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesAggregationScanOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesAggregationScanOperator.java
@@ -21,7 +21,7 @@ package org.apache.iotdb.db.queryengine.execution.operator.source;
 
 import org.apache.iotdb.commons.path.AlignedFullPath;
 import org.apache.iotdb.db.queryengine.execution.MemoryEstimationHelper;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
 import org.apache.iotdb.db.queryengine.execution.operator.OperatorContext;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeId;
@@ -47,7 +47,7 @@ public class AlignedSeriesAggregationScanOperator extends AbstractSeriesAggregat
       Ordering scanOrder,
       SeriesScanOptions scanOptions,
       OperatorContext context,
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       ITimeRangeIterator timeRangeIterator,
       GroupByTimeParameter groupByTimeParameter,
       long maxReturnSize,
@@ -73,7 +73,7 @@ public class AlignedSeriesAggregationScanOperator extends AbstractSeriesAggregat
       boolean outputEndTime,
       SeriesScanOptions scanOptions,
       OperatorContext context,
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       ITimeRangeIterator timeRangeIterator,
       GroupByTimeParameter groupByTimeParameter,
       long maxReturnSize,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/SeriesAggregationScanOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/SeriesAggregationScanOperator.java
index 72a67e0fe2b..3ba72b68fc0 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/SeriesAggregationScanOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/SeriesAggregationScanOperator.java
@@ -21,7 +21,7 @@ package org.apache.iotdb.db.queryengine.execution.operator.source;
 
 import org.apache.iotdb.commons.path.IFullPath;
 import org.apache.iotdb.db.queryengine.execution.MemoryEstimationHelper;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
 import org.apache.iotdb.db.queryengine.execution.operator.OperatorContext;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeId;
@@ -54,7 +54,7 @@ public class SeriesAggregationScanOperator extends AbstractSeriesAggregationScan
       Ordering scanOrder,
       SeriesScanOptions scanOptions,
       OperatorContext context,
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       ITimeRangeIterator timeRangeIterator,
       GroupByTimeParameter groupByTimeParameter,
       long maxReturnSize,
@@ -80,7 +80,7 @@ public class SeriesAggregationScanOperator extends AbstractSeriesAggregationScan
       boolean outputEndTime,
       SeriesScanOptions scanOptions,
       OperatorContext context,
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       ITimeRangeIterator timeRangeIterator,
       GroupByTimeParameter groupByTimeParameter,
       long maxReturnSize,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/TableAggregationTableScanOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/TableAggregationTableScanOperator.java
new file mode 100644
index 00000000000..1718f460e58
--- /dev/null
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/TableAggregationTableScanOperator.java
@@ -0,0 +1,661 @@
+/*
+ * 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.execution.operator.source.relational;
+
+import org.apache.iotdb.commons.path.AlignedFullPath;
+import org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory;
+import org.apache.iotdb.db.queryengine.execution.MemoryEstimationHelper;
+import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
+import org.apache.iotdb.db.queryengine.execution.operator.OperatorContext;
+import org.apache.iotdb.db.queryengine.execution.operator.source.AbstractSeriesAggregationScanOperator;
+import org.apache.iotdb.db.queryengine.execution.operator.source.AlignedSeriesScanUtil;
+import org.apache.iotdb.db.queryengine.execution.operator.source.relational.aggregation.TableAggregator;
+import org.apache.iotdb.db.queryengine.execution.operator.window.IWindow;
+import org.apache.iotdb.db.queryengine.execution.operator.window.TimeWindow;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeId;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.GroupByTimeParameter;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.SeriesScanOptions;
+import org.apache.iotdb.db.queryengine.plan.relational.metadata.ColumnSchema;
+import org.apache.iotdb.db.queryengine.plan.relational.metadata.DeviceEntry;
+import org.apache.iotdb.db.queryengine.plan.statement.component.Ordering;
+import org.apache.iotdb.db.storageengine.dataregion.read.IQueryDataSource;
+import org.apache.iotdb.db.storageengine.dataregion.read.QueryDataSource;
+
+import org.apache.commons.lang3.stream.Streams;
+import org.apache.tsfile.block.column.Column;
+import org.apache.tsfile.block.column.ColumnBuilder;
+import org.apache.tsfile.enums.TSDataType;
+import org.apache.tsfile.file.metadata.statistics.Statistics;
+import org.apache.tsfile.read.common.TimeRange;
+import org.apache.tsfile.read.common.block.TsBlock;
+import org.apache.tsfile.read.common.block.TsBlockBuilder;
+import org.apache.tsfile.read.common.block.column.LongColumn;
+import org.apache.tsfile.read.common.block.column.RunLengthEncodedColumn;
+import org.apache.tsfile.utils.Binary;
+import org.apache.tsfile.utils.Pair;
+import org.apache.tsfile.utils.RamUsageEstimator;
+import org.apache.tsfile.write.schema.IMeasurementSchema;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import static java.lang.String.format;
+import static org.apache.iotdb.db.queryengine.execution.operator.AggregationUtil.satisfiedTimeRange;
+import static org.apache.iotdb.db.queryengine.execution.operator.source.relational.TableScanOperator.constructAlignedPath;
+import static org.apache.tsfile.read.common.block.TsBlockUtil.skipPointsOutOfTimeRange;
+
+public class TableAggregationTableScanOperator extends AbstractSeriesAggregationScanOperator {
+
+  private static final long INSTANCE_SIZE =
+      RamUsageEstimator.shallowSizeOfInstance(TableAggregationTableScanOperator.class);
+
+  private final List<TableAggregator> tableAggregators;
+
+  private final List<ColumnSchema> groupingKeySchemas;
+  private final int[] groupingKeyIndex;
+
+  public static final LongColumn TIME_COLUMN_TEMPLATE =
+      new LongColumn(1, Optional.empty(), new long[] {0});
+
+  private final List<ColumnSchema> columnSchemas;
+
+  private final int[] columnsIndexArray;
+
+  private final List<DeviceEntry> deviceEntries;
+
+  private final int deviceCount;
+
+  private final Ordering scanOrder;
+  private final SeriesScanOptions seriesScanOptions;
+
+  private final List<String> measurementColumnNames;
+
+  private final List<IMeasurementSchema> measurementSchemas;
+
+  private final List<TSDataType> measurementColumnTSDataTypes;
+
+  // TODO calc maxTsBlockLineNum using date_bin
+  private final int maxTsBlockLineNum;
+
+  // for different aggregations aiming to same column, use this variable to point to same column
+  private final int[] layoutArray;
+
+  private QueryDataSource queryDataSource;
+
+  private int currentDeviceIndex;
+
+  public TableAggregationTableScanOperator(
+      PlanNodeId sourceId,
+      OperatorContext context,
+      List<ColumnSchema> columnSchemas,
+      int[] columnsIndexArray,
+      List<DeviceEntry> deviceEntries,
+      Ordering scanOrder,
+      SeriesScanOptions seriesScanOptions,
+      List<String> measurementColumnNames,
+      List<IMeasurementSchema> measurementSchemas,
+      int maxTsBlockLineNum,
+      int subSensorSize,
+      List<TableAggregator> tableAggregators,
+      List<ColumnSchema> groupingKeySchemas,
+      int[] groupingKeyIndex,
+      ITimeRangeIterator timeRangeIterator,
+      boolean ascending,
+      GroupByTimeParameter groupByTimeParameter,
+      long maxReturnSize,
+      boolean canUseStatistics,
+      int[] layoutArray) {
+
+    super(
+        sourceId,
+        context,
+        null,
+        subSensorSize,
+        null,
+        timeRangeIterator,
+        ascending,
+        false,
+        groupByTimeParameter,
+        maxReturnSize,
+        canUseStatistics);
+
+    this.tableAggregators = tableAggregators;
+    this.groupingKeySchemas = groupingKeySchemas;
+    this.groupingKeyIndex = groupingKeyIndex;
+
+    this.sourceId = sourceId;
+    this.operatorContext = context;
+    this.columnSchemas = columnSchemas;
+    this.columnsIndexArray = columnsIndexArray;
+    this.deviceEntries = deviceEntries;
+    this.deviceCount = deviceEntries.size();
+    this.scanOrder = scanOrder;
+    this.seriesScanOptions = seriesScanOptions;
+    this.measurementColumnNames = measurementColumnNames;
+    this.measurementSchemas = measurementSchemas;
+    this.measurementColumnTSDataTypes =
+        measurementSchemas.stream().map(IMeasurementSchema::getType).collect(Collectors.toList());
+    this.currentDeviceIndex = 0;
+    this.layoutArray = layoutArray;
+
+    this.maxReturnSize = maxReturnSize;
+    this.maxTsBlockLineNum = maxTsBlockLineNum;
+
+    this.seriesScanUtil = constructAlignedSeriesScanUtil(deviceEntries.get(currentDeviceIndex));
+  }
+
+  @Override
+  public boolean hasNext() throws Exception {
+    return !isFinished();
+  }
+
+  @Override
+  public TsBlock next() throws Exception {
+
+    // optimize for sql: select count(*) from (select count(s1), sum(s1) from table)
+    if (tableAggregators.isEmpty()) {
+      retainedTsBlock = null;
+      currentDeviceIndex = deviceCount;
+      Column[] valueColumns = new Column[0];
+      return new TsBlock(1, new RunLengthEncodedColumn(TIME_COLUMN_TEMPLATE, 1), valueColumns);
+    }
+
+    // start stopwatch, reset leftRuntimeOfOneNextCall
+    long start = System.nanoTime();
+    leftRuntimeOfOneNextCall = operatorContext.getMaxRunTime().roundTo(TimeUnit.NANOSECONDS);
+    long maxRuntime = leftRuntimeOfOneNextCall;
+
+    while (System.nanoTime() - start < maxRuntime
+        && (curTimeRange != null || timeRangeIterator.hasNextTimeRange())
+        && !resultTsBlockBuilder.isFull()) {
+      if (curTimeRange == null) {
+        // move to the next time window
+        curTimeRange = timeRangeIterator.nextTimeRange();
+        // clear previous aggregation result
+        for (TableAggregator aggregator : tableAggregators) {
+          aggregator.reset();
+        }
+      }
+
+      // calculate aggregation result on current time window
+      // Keep curTimeRange if the calculation of this timeRange is not done
+      if (calculateAggregationResultForCurrentTimeRange()) {
+        // updateResultTsBlock();
+        curTimeRange = null;
+      }
+    }
+
+    if (resultTsBlockBuilder.getPositionCount() > 0) {
+      int declaredPositions = resultTsBlockBuilder.getPositionCount();
+      ColumnBuilder[] valueColumnBuilders = resultTsBlockBuilder.getValueColumnBuilders();
+      Column[] valueColumns = new Column[valueColumnBuilders.length];
+      for (int i = 0; i < valueColumns.length; i++) {
+        valueColumns[i] = valueColumnBuilders[i].build();
+        if (valueColumns[i].getPositionCount() != declaredPositions) {
+          throw new IllegalStateException(
+              format(
+                  "Declared positions (%s) does not match column %s's number of entries (%s)",
+                  declaredPositions, i, valueColumns[i].getPositionCount()));
+        }
+      }
+
+      this.resultTsBlock =
+          new TsBlock(
+              resultTsBlockBuilder.getPositionCount(),
+              new RunLengthEncodedColumn(
+                  TIME_COLUMN_TEMPLATE, resultTsBlockBuilder.getPositionCount()),
+              valueColumns);
+      resultTsBlockBuilder.reset();
+      return this.resultTsBlock;
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public boolean isFinished() throws Exception {
+    return (retainedTsBlock == null)
+        && (currentDeviceIndex >= deviceCount || seriesScanOptions.limitConsumedUp());
+  }
+
+  @Override
+  public long ramBytesUsed() {
+    return INSTANCE_SIZE
+        + MemoryEstimationHelper.getEstimatedSizeOfAccountableObject(seriesScanUtil)
+        + MemoryEstimationHelper.getEstimatedSizeOfAccountableObject(operatorContext)
+        + MemoryEstimationHelper.getEstimatedSizeOfAccountableObject(sourceId)
+        + (resultTsBlockBuilder == null ? 0 : resultTsBlockBuilder.getRetainedSizeInBytes())
+        + RamUsageEstimator.sizeOfCollection(deviceEntries);
+  }
+
+  private AlignedSeriesScanUtil constructAlignedSeriesScanUtil(DeviceEntry deviceEntry) {
+    AlignedFullPath alignedPath =
+        constructAlignedPath(deviceEntry, measurementColumnNames, measurementSchemas);
+
+    return new AlignedSeriesScanUtil(
+        alignedPath,
+        scanOrder,
+        seriesScanOptions,
+        operatorContext.getInstanceContext(),
+        true,
+        measurementColumnTSDataTypes);
+  }
+
+  /** Return true if we have the result of this timeRange. */
+  protected boolean calculateAggregationResultForCurrentTimeRange() {
+    try {
+      if (calcFromCachedData()) {
+        updateResultTsBlock();
+        return true;
+      }
+
+      if (readAndCalcFromPage()) {
+        updateResultTsBlock();
+        return true;
+      }
+
+      // only when all the page data has been consumed, we need to read the chunk data
+      if (!seriesScanUtil.hasNextPage() && readAndCalcFromChunk()) {
+        updateResultTsBlock();
+        return true;
+      }
+
+      // only when all the page and chunk data has been consumed, we need to read the file data
+      if (!seriesScanUtil.hasNextPage()
+          && !seriesScanUtil.hasNextChunk()
+          && readAndCalcFromFile()) {
+        updateResultTsBlock();
+        return true;
+      }
+
+      // If the TimeRange is (Long.MIN_VALUE, Long.MAX_VALUE), for Aggregators like countAggregator,
+      // we have to consume all the data before we finish the aggregation calculation.
+      if (seriesScanUtil.hasNextPage()
+          || seriesScanUtil.hasNextChunk()
+          || seriesScanUtil.hasNextFile()) {
+        return false;
+      } else {
+        updateResultTsBlock();
+        for (TableAggregator aggregator : tableAggregators) {
+          aggregator.reset();
+        }
+        currentDeviceIndex++;
+      }
+      if (currentDeviceIndex < deviceCount) {
+        // construct AlignedSeriesScanUtil for next device
+        this.seriesScanUtil = constructAlignedSeriesScanUtil(deviceEntries.get(currentDeviceIndex));
+
+        // reset QueryDataSource
+        queryDataSource.reset();
+        this.seriesScanUtil.initQueryDataSource(queryDataSource);
+      }
+      return currentDeviceIndex >= deviceCount;
+    } catch (IOException e) {
+      throw new RuntimeException("Error while scanning the file", e);
+    }
+  }
+
+  @Override
+  public void initQueryDataSource(IQueryDataSource dataSource) {
+    this.queryDataSource = (QueryDataSource) dataSource;
+    this.seriesScanUtil.initQueryDataSource(queryDataSource);
+    this.resultTsBlockBuilder = new TsBlockBuilder(getResultDataTypes());
+    this.resultTsBlockBuilder.setMaxTsBlockLineNumber(this.maxTsBlockLineNum);
+  }
+
+  @Override
+  protected void updateResultTsBlock() {
+    appendAggregationResult(resultTsBlockBuilder, tableAggregators);
+  }
+
+  protected boolean calcFromCachedData() {
+    return calcFromRawData(inputTsBlock);
+  }
+
+  private boolean calcFromRawData(TsBlock tsBlock) {
+    Pair<Boolean, TsBlock> calcResult =
+        calculateAggregationFromRawData(tsBlock, tableAggregators, curTimeRange, ascending);
+    inputTsBlock = calcResult.getRight();
+    return calcResult.getLeft();
+  }
+
+  /**
+   * Calculate aggregation value on the time range from the tsBlock containing raw data.
+   *
+   * @return left - whether the aggregation calculation of the current time range has done; right -
+   *     remaining tsBlock
+   */
+  public Pair<Boolean, TsBlock> calculateAggregationFromRawData(
+      TsBlock inputTsBlock,
+      List<TableAggregator> aggregators,
+      TimeRange curTimeRange,
+      boolean ascending) {
+    if (inputTsBlock == null || inputTsBlock.isEmpty()) {
+      return new Pair<>(false, inputTsBlock);
+    }
+
+    // check if the tsBlock does not contain points in current interval
+    if (satisfiedTimeRange(inputTsBlock, curTimeRange, ascending)) {
+      // skip points that cannot be calculated
+      if ((ascending && inputTsBlock.getStartTime() < curTimeRange.getMin())
+          || (!ascending && inputTsBlock.getStartTime() > curTimeRange.getMax())) {
+        inputTsBlock = skipPointsOutOfTimeRange(inputTsBlock, curTimeRange, ascending);
+      }
+
+      inputTsBlock = process(inputTsBlock, curTimeRange, aggregators);
+    }
+
+    // judge whether the calculation finished
+    boolean isTsBlockOutOfBound =
+        inputTsBlock != null
+            && (ascending
+                ? inputTsBlock.getEndTime() > curTimeRange.getMax()
+                : inputTsBlock.getEndTime() < curTimeRange.getMin());
+    return new Pair<>(
+        isAllAggregatorsHasFinalResult(aggregators) || isTsBlockOutOfBound, inputTsBlock);
+  }
+
+  private TsBlock process(
+      TsBlock inputTsBlock, TimeRange curTimeRange, List<TableAggregator> aggregators) {
+    // Get the row which need to be processed by aggregator
+    IWindow curWindow = new TimeWindow(curTimeRange);
+    Column timeColumn = inputTsBlock.getTimeColumn();
+    int lastIndexToProcess = 0;
+    for (int i = 0; i < inputTsBlock.getPositionCount(); i++) {
+      if (!curWindow.satisfy(timeColumn, i)) {
+        break;
+      }
+      lastIndexToProcess = i;
+    }
+
+    TsBlock inputRegion = inputTsBlock.getRegion(0, lastIndexToProcess + 1);
+    for (int i = 0; i < aggregators.size(); i++) {
+      if (isNullIdOrAttribute(i)) {
+        continue;
+      }
+
+      TableAggregator aggregator = aggregators.get(i);
+      // current agg method has been calculated
+      if (aggregator.hasFinalResult()) {
+        continue;
+      }
+
+      aggregator.processBlock(inputRegion);
+    }
+    int lastReadRowIndex = lastIndexToProcess + 1;
+    if (lastReadRowIndex >= inputTsBlock.getPositionCount()) {
+      return null;
+    } else {
+      return inputTsBlock.subTsBlock(lastReadRowIndex);
+    }
+  }
+
+  /** ID or Attribute is null, skip this aggregation logic */
+  private boolean isNullIdOrAttribute(int i) {
+    if (TsTableColumnCategory.ID == columnSchemas.get(layoutArray[i]).getColumnCategory()
+        && deviceEntries.get(currentDeviceIndex).getNthSegment(columnsIndexArray[i] + 1) == null) {
+      return true;
+    }
+
+    return TsTableColumnCategory.ATTRIBUTE == columnSchemas.get(layoutArray[i]).getColumnCategory()
+        && deviceEntries
+                .get(currentDeviceIndex)
+                .getAttributeColumnValues()
+                .get(columnsIndexArray[i])
+            == null;
+  }
+
+  public static boolean isAllAggregatorsHasFinalResult(List<TableAggregator> aggregators) {
+    for (TableAggregator aggregator : aggregators) {
+      if (!aggregator.hasFinalResult()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  protected void calcFromStatistics(Statistics timeStatistics, Statistics[] valueStatistics) {
+    for (int i = 0; i < tableAggregators.size(); i++) {
+      if (isNullIdOrAttribute(i)) {
+        continue;
+      }
+
+      TableAggregator aggregator = tableAggregators.get(i);
+      if (aggregator.hasFinalResult()) {
+        continue;
+      }
+      aggregator.processStatistics(
+          columnSchemas.get(layoutArray[i]).getColumnCategory() == TsTableColumnCategory.MEASUREMENT
+              ? valueStatistics[columnsIndexArray[i]]
+              : timeStatistics);
+    }
+  }
+
+  @SuppressWarnings({"squid:S3776", "squid:S135", "squid:S3740"})
+  protected boolean readAndCalcFromFile() throws IOException {
+    // start stopwatch
+    long start = System.nanoTime();
+    while (System.nanoTime() - start < leftRuntimeOfOneNextCall && seriesScanUtil.hasNextFile()) {
+      if (canUseStatistics && seriesScanUtil.canUseCurrentFileStatistics()) {
+        Statistics fileTimeStatistics = seriesScanUtil.currentFileTimeStatistics();
+        if (fileTimeStatistics.getStartTime() > curTimeRange.getMax()) {
+          if (ascending) {
+            return true;
+          } else {
+            seriesScanUtil.skipCurrentFile();
+            continue;
+          }
+        }
+        // calc from fileMetaData
+        if (curTimeRange.contains(
+            fileTimeStatistics.getStartTime(), fileTimeStatistics.getEndTime())) {
+          Statistics[] statisticsList = new Statistics[subSensorSize];
+          for (int i = 0; i < subSensorSize; i++) {
+            statisticsList[i] = seriesScanUtil.currentFileStatistics(i);
+          }
+          calcFromStatistics(fileTimeStatistics, statisticsList);
+          seriesScanUtil.skipCurrentFile();
+          if (isAllAggregatorsHasFinalResult(tableAggregators) && !isGroupByQuery) {
+            return true;
+          } else {
+            continue;
+          }
+        }
+      }
+
+      // read chunk
+      if (readAndCalcFromChunk()) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  @SuppressWarnings({"squid:S3776", "squid:S135", "squid:S3740"})
+  protected boolean readAndCalcFromChunk() throws IOException {
+    // start stopwatch
+    long start = System.nanoTime();
+    while (System.nanoTime() - start < leftRuntimeOfOneNextCall && seriesScanUtil.hasNextChunk()) {
+      if (canUseStatistics && seriesScanUtil.canUseCurrentChunkStatistics()) {
+        Statistics chunkTimeStatistics = seriesScanUtil.currentChunkTimeStatistics();
+        if (chunkTimeStatistics.getStartTime() > curTimeRange.getMax()) {
+          if (ascending) {
+            return true;
+          } else {
+            seriesScanUtil.skipCurrentChunk();
+            continue;
+          }
+        }
+        // calc from chunkMetaData
+        if (curTimeRange.contains(
+            chunkTimeStatistics.getStartTime(), chunkTimeStatistics.getEndTime())) {
+          // calc from chunkMetaData
+          Statistics[] statisticsList = new Statistics[subSensorSize];
+          for (int i = 0; i < subSensorSize; i++) {
+            statisticsList[i] = seriesScanUtil.currentChunkStatistics(i);
+          }
+          calcFromStatistics(chunkTimeStatistics, statisticsList);
+          seriesScanUtil.skipCurrentChunk();
+          if (isAllAggregatorsHasFinalResult(tableAggregators) && !isGroupByQuery) {
+            return true;
+          } else {
+            continue;
+          }
+        }
+      }
+
+      // read page
+      if (readAndCalcFromPage()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  long leftRuntimeOfOneNextCall = Long.MAX_VALUE;
+
+  @SuppressWarnings({"squid:S3776", "squid:S135", "squid:S3740"})
+  protected boolean readAndCalcFromPage() throws IOException {
+    long start = System.nanoTime();
+    try {
+      while (System.nanoTime() - start < leftRuntimeOfOneNextCall && seriesScanUtil.hasNextPage()) {
+        if (canUseStatistics && seriesScanUtil.canUseCurrentPageStatistics()) {
+          Statistics pageTimeStatistics = seriesScanUtil.currentPageTimeStatistics();
+          // There is no more eligible points in current time range
+          if (pageTimeStatistics.getStartTime() > curTimeRange.getMax()) {
+            if (ascending) {
+              return true;
+            } else {
+              seriesScanUtil.skipCurrentPage();
+              continue;
+            }
+          }
+          // can use pageHeader
+          if (curTimeRange.contains(
+              pageTimeStatistics.getStartTime(), pageTimeStatistics.getEndTime())) {
+            Statistics[] statisticsList = new Statistics[subSensorSize];
+            for (int i = 0; i < subSensorSize; i++) {
+              statisticsList[i] = seriesScanUtil.currentPageStatistics(i);
+            }
+            calcFromStatistics(pageTimeStatistics, statisticsList);
+            seriesScanUtil.skipCurrentPage();
+            if (isAllAggregatorsHasFinalResult(tableAggregators) && !isGroupByQuery) {
+              return true;
+            } else {
+              continue;
+            }
+          }
+        }
+
+        // calc from page data
+        TsBlock originalTsBlock = seriesScanUtil.nextPage();
+        if (originalTsBlock == null) {
+          continue;
+        }
+        // TODO(beyyes) add optimization: if only agg measurement columns, no need to transfer
+        Column[] valueColumns = new Column[tableAggregators.size()];
+        for (int i = 0; i < tableAggregators.size(); i++) {
+          ColumnSchema columnSchema = columnSchemas.get(layoutArray[i]);
+          if (Streams.of(
+                  TsTableColumnCategory.ID,
+                  TsTableColumnCategory.ATTRIBUTE,
+                  TsTableColumnCategory.TIME)
+              .anyMatch(columnSchema.getColumnCategory()::equals)) {
+            valueColumns[i] = originalTsBlock.getTimeColumn();
+          } else {
+            valueColumns[i] = originalTsBlock.getColumn(i);
+          }
+        }
+        TsBlock tsBlock =
+            new TsBlock(
+                originalTsBlock.getPositionCount(),
+                new RunLengthEncodedColumn(
+                    TIME_COLUMN_TEMPLATE, originalTsBlock.getPositionCount()),
+                valueColumns);
+        if (tsBlock.isEmpty()) {
+          continue;
+        }
+
+        // calc from raw data
+        if (calcFromRawData(tsBlock)) {
+          return true;
+        }
+      }
+      return false;
+    } finally {
+      leftRuntimeOfOneNextCall -= (System.nanoTime() - start);
+    }
+  }
+
+  @Override
+  protected List<TSDataType> getResultDataTypes() {
+    List<TSDataType> resultDataTypes =
+        new ArrayList<>(
+            (groupingKeyIndex != null ? groupingKeyIndex.length : 0) + tableAggregators.size());
+    if (groupingKeyIndex != null) {
+      for (int i = 0; i < groupingKeyIndex.length; i++) {
+        resultDataTypes.add(TSDataType.TEXT);
+      }
+    }
+
+    for (TableAggregator aggregator : tableAggregators) {
+      resultDataTypes.add(aggregator.getType());
+    }
+
+    return resultDataTypes;
+  }
+
+  /** Append a row of aggregation results to the result tsBlock. */
+  public void appendAggregationResult(
+      TsBlockBuilder tsBlockBuilder, List<? extends TableAggregator> aggregators) {
+    ColumnBuilder[] columnBuilders = tsBlockBuilder.getValueColumnBuilders();
+
+    if (groupingKeyIndex != null) {
+      for (int i = 0; i < groupingKeyIndex.length; i++) {
+        if (TsTableColumnCategory.ID == groupingKeySchemas.get(i).getColumnCategory()) {
+          columnBuilders[i].writeBinary(
+              (Binary)
+                  deviceEntries.get(currentDeviceIndex).getNthSegment(groupingKeyIndex[i] + 1));
+        } else {
+          columnBuilders[i].writeBinary(
+              new Binary(
+                  deviceEntries
+                      .get(currentDeviceIndex)
+                      .getAttributeColumnValues()
+                      .get(groupingKeyIndex[i])
+                      .getBytes()));
+        }
+      }
+    }
+
+    int groupKeyLength = groupingKeyIndex == null ? 0 : groupingKeyIndex.length;
+
+    for (int i = 0; i < aggregators.size(); i++) {
+      aggregators.get(groupKeyLength + i).evaluate(columnBuilders[groupKeyLength + i]);
+    }
+
+    tsBlockBuilder.declarePosition();
+  }
+}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/TableScanOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/TableScanOperator.java
index 90982549716..e282f1b3e63 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/TableScanOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/TableScanOperator.java
@@ -66,8 +66,6 @@ public class TableScanOperator extends AbstractSeriesScanOperator {
 
   private final int[] columnsIndexArray;
 
-  private final int measurementColumnCount;
-
   private final List<DeviceEntry> deviceEntries;
 
   private final int deviceCount;
@@ -96,7 +94,6 @@ public class TableScanOperator extends AbstractSeriesScanOperator {
       PlanNodeId sourceId,
       List<ColumnSchema> columnSchemas,
       int[] columnsIndexArray,
-      int measurementColumnCount,
       List<DeviceEntry> deviceEntries,
       Ordering scanOrder,
       SeriesScanOptions seriesScanOptions,
@@ -107,7 +104,6 @@ public class TableScanOperator extends AbstractSeriesScanOperator {
     this.operatorContext = context;
     this.columnSchemas = columnSchemas;
     this.columnsIndexArray = columnsIndexArray;
-    this.measurementColumnCount = measurementColumnCount;
     this.deviceEntries = deviceEntries;
     this.deviceCount = deviceEntries.size();
     this.scanOrder = scanOrder;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AccumulatorFactory.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AccumulatorFactory.java
index e9205e3fd42..d3775df5f12 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AccumulatorFactory.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AccumulatorFactory.java
@@ -33,7 +33,7 @@ import static com.google.common.base.Preconditions.checkState;
 
 public class AccumulatorFactory {
 
-  public static Accumulator createAccumulator(
+  public static TableAccumulator createAccumulator(
       String functionName,
       TAggregationType aggregationType,
       List<TSDataType> inputDataTypes,
@@ -49,7 +49,7 @@ public class AccumulatorFactory {
     }
   }
 
-  public static Accumulator createBuiltinAccumulator(
+  public static TableAccumulator createBuiltinAccumulator(
       TAggregationType aggregationType,
       List<TSDataType> inputDataTypes,
       List<Expression> inputExpressions,
@@ -75,7 +75,7 @@ public class AccumulatorFactory {
     }
   }
 
-  public static Accumulator createBuiltinMultiInputAccumulator(
+  public static TableAccumulator createBuiltinMultiInputAccumulator(
       TAggregationType aggregationType, List<TSDataType> inputDataTypes) {
     switch (aggregationType) {
       case MAX_BY:
@@ -89,7 +89,7 @@ public class AccumulatorFactory {
     }
   }
 
-  private static Accumulator createBuiltinSingleInputAccumulator(
+  private static TableAccumulator createBuiltinSingleInputAccumulator(
       TAggregationType aggregationType,
       TSDataType tsDataType,
       List<Expression> inputExpressions,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AggregationOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AggregationOperator.java
index 425f05f7867..3da8ba5c84f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AggregationOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AggregationOperator.java
@@ -47,7 +47,7 @@ public class AggregationOperator implements ProcessOperator {
 
   private final Operator child;
 
-  private final List<Aggregator> aggregators;
+  private final List<TableAggregator> aggregators;
 
   private final TsBlockBuilder resultBuilder;
 
@@ -61,13 +61,13 @@ public class AggregationOperator implements ProcessOperator {
   private boolean finished = false;
 
   public AggregationOperator(
-      OperatorContext operatorContext, Operator child, List<Aggregator> aggregators) {
+      OperatorContext operatorContext, Operator child, List<TableAggregator> aggregators) {
     this.operatorContext = operatorContext;
     this.child = child;
     this.aggregators = aggregators;
     this.resultBuilder =
         new TsBlockBuilder(
-            aggregators.stream().map(Aggregator::getType).collect(toImmutableList()));
+            aggregators.stream().map(TableAggregator::getType).collect(toImmutableList()));
     this.resultColumnsBuilder = resultBuilder.getValueColumnBuilders();
     this.memoryReservationManager =
         operatorContext
@@ -96,7 +96,7 @@ public class AggregationOperator implements ProcessOperator {
         return null;
       }
 
-      for (Aggregator aggregator : aggregators) {
+      for (TableAggregator aggregator : aggregators) {
         aggregator.processBlock(block);
       }
 
@@ -151,7 +151,7 @@ public class AggregationOperator implements ProcessOperator {
   public long ramBytesUsed() {
     return INSTANCE_SIZE
         + MemoryEstimationHelper.getEstimatedSizeOfAccountableObject(child)
-        + aggregators.stream().mapToLong(Aggregator::getEstimatedSize).count()
+        + aggregators.stream().mapToLong(TableAggregator::getEstimatedSize).count()
         + MemoryEstimationHelper.getEstimatedSizeOfAccountableObject(operatorContext)
         + resultBuilder.getRetainedSizeInBytes();
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AvgAccumulator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AvgAccumulator.java
index d5c9eff3630..45d991d946e 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AvgAccumulator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/AvgAccumulator.java
@@ -21,6 +21,8 @@ package org.apache.iotdb.db.queryengine.execution.operator.source.relational.agg
 import org.apache.tsfile.block.column.Column;
 import org.apache.tsfile.block.column.ColumnBuilder;
 import org.apache.tsfile.enums.TSDataType;
+import org.apache.tsfile.file.metadata.statistics.IntegerStatistics;
+import org.apache.tsfile.file.metadata.statistics.Statistics;
 import org.apache.tsfile.read.common.block.column.BinaryColumn;
 import org.apache.tsfile.read.common.block.column.BinaryColumnBuilder;
 import org.apache.tsfile.utils.Binary;
@@ -34,7 +36,7 @@ import java.io.IOException;
 
 import static com.google.common.base.Preconditions.checkArgument;
 
-public class AvgAccumulator implements Accumulator {
+public class AvgAccumulator implements TableAccumulator {
   private static final long INSTANCE_SIZE =
       RamUsageEstimator.shallowSizeOfInstance(AvgAccumulator.class);
   private final TSDataType argumentDataType;
@@ -52,7 +54,7 @@ public class AvgAccumulator implements Accumulator {
   }
 
   @Override
-  public Accumulator copy() {
+  public TableAccumulator copy() {
     return new AvgAccumulator(argumentDataType);
   }
 
@@ -89,11 +91,19 @@ public class AvgAccumulator implements Accumulator {
     checkArgument(
         argument instanceof BinaryColumn,
         "intermediate input and output of Avg should be BinaryColumn");
-    if (argument.isNull(0)) {
-      return;
+
+    for (int i = 0; i < argument.getPositionCount(); i++) {
+      if (argument.isNull(i)) {
+        continue;
+      }
+
+      initResult = true;
+      long midCountValue = BytesUtils.bytesToLong(argument.getBinary(i).getValues(), Long.BYTES);
+      double midSumValue = BytesUtils.bytesToDouble(argument.getBinary(i).getValues(), Long.BYTES);
+      countValue += midCountValue;
+      sumValue += midSumValue;
     }
-    initResult = true;
-    deserialize(argument.getBinary(0).getValues());
+
     if (countValue == 0) {
       initResult = false;
     }
@@ -111,11 +121,6 @@ public class AvgAccumulator implements Accumulator {
     }
   }
 
-  private void deserialize(byte[] bytes) {
-    countValue = BytesUtils.bytesToLong(bytes, Long.BYTES);
-    sumValue = BytesUtils.bytesToDouble(bytes, Long.BYTES);
-  }
-
   private byte[] serializeState() {
     ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
     DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);
@@ -182,6 +187,28 @@ public class AvgAccumulator implements Accumulator {
     }
   }
 
+  @Override
+  public boolean hasFinalResult() {
+    return false;
+  }
+
+  @Override
+  public void addStatistics(Statistics statistics) {
+    if (statistics == null) {
+      return;
+    }
+    initResult = true;
+    countValue += statistics.getCount();
+    if (statistics instanceof IntegerStatistics) {
+      sumValue += statistics.getSumLongValue();
+    } else {
+      sumValue += statistics.getSumDoubleValue();
+    }
+    if (countValue == 0) {
+      initResult = false;
+    }
+  }
+
   @Override
   public void reset() {
     initResult = false;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/CountAccumulator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/CountAccumulator.java
index 3f876564376..b179e76a38c 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/CountAccumulator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/CountAccumulator.java
@@ -20,11 +20,12 @@ package org.apache.iotdb.db.queryengine.execution.operator.source.relational.agg
 
 import org.apache.tsfile.block.column.Column;
 import org.apache.tsfile.block.column.ColumnBuilder;
+import org.apache.tsfile.file.metadata.statistics.Statistics;
 import org.apache.tsfile.utils.RamUsageEstimator;
 
 import static com.google.common.base.Preconditions.checkArgument;
 
-public class CountAccumulator implements Accumulator {
+public class CountAccumulator implements TableAccumulator {
   private static final long INSTANCE_SIZE =
       RamUsageEstimator.shallowSizeOfInstance(CountAccumulator.class);
   private long countState = 0;
@@ -35,7 +36,7 @@ public class CountAccumulator implements Accumulator {
   }
 
   @Override
-  public Accumulator copy() {
+  public TableAccumulator copy() {
     return new CountAccumulator();
   }
 
@@ -56,11 +57,12 @@ public class CountAccumulator implements Accumulator {
 
   @Override
   public void addIntermediate(Column argument) {
-    checkArgument(argument.getPositionCount() == 1, "partialResult should always be one line");
-    if (argument.isNull(0)) {
-      return;
+    for (int i = 0; i < argument.getPositionCount(); i++) {
+      if (argument.isNull(i)) {
+        continue;
+      }
+      countState += argument.getLong(i);
     }
-    countState += argument.getLong(0);
   }
 
   @Override
@@ -73,6 +75,19 @@ public class CountAccumulator implements Accumulator {
     columnBuilder.writeLong(countState);
   }
 
+  @Override
+  public boolean hasFinalResult() {
+    return false;
+  }
+
+  @Override
+  public void addStatistics(Statistics statistics) {
+    if (statistics == null) {
+      return;
+    }
+    countState += statistics.getCount();
+  }
+
   @Override
   public void reset() {
     countState = 0;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/Accumulator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/TableAccumulator.java
similarity index 66%
rename from iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/Accumulator.java
rename to iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/TableAccumulator.java
index 734fa21c00c..30cb908b43b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/Accumulator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/TableAccumulator.java
@@ -15,11 +15,12 @@ package org.apache.iotdb.db.queryengine.execution.operator.source.relational.agg
 
 import org.apache.tsfile.block.column.Column;
 import org.apache.tsfile.block.column.ColumnBuilder;
+import org.apache.tsfile.file.metadata.statistics.Statistics;
 
-public interface Accumulator {
+public interface TableAccumulator {
   long getEstimatedSize();
 
-  Accumulator copy();
+  TableAccumulator copy();
 
   void addInput(Column[] arguments);
 
@@ -29,5 +30,17 @@ public interface Accumulator {
 
   void evaluateFinal(ColumnBuilder columnBuilder);
 
+  /**
+   * This method can only be used in AggTableScan. For first/first_by or last/last_by in decreasing
+   * order, we can get final result by the first record.
+   */
+  boolean hasFinalResult();
+
+  /**
+   * This method can only be used in AggTableScan, it will use different statistics based on the
+   * type of Accumulator.
+   */
+  void addStatistics(Statistics statistics);
+
   void reset();
 }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/Aggregator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/TableAggregator.java
similarity index 84%
rename from iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/Aggregator.java
rename to iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/TableAggregator.java
index ada8ce9ffb5..fae3dee8de0 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/Aggregator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/aggregation/TableAggregator.java
@@ -19,6 +19,7 @@ import com.google.common.primitives.Ints;
 import org.apache.tsfile.block.column.Column;
 import org.apache.tsfile.block.column.ColumnBuilder;
 import org.apache.tsfile.enums.TSDataType;
+import org.apache.tsfile.file.metadata.statistics.Statistics;
 import org.apache.tsfile.read.common.block.TsBlock;
 import org.apache.tsfile.read.common.block.column.RunLengthEncodedColumn;
 
@@ -29,15 +30,15 @@ import static com.google.common.base.Preconditions.checkArgument;
 import static java.util.Objects.requireNonNull;
 import static org.apache.iotdb.db.queryengine.execution.operator.source.relational.TableScanOperator.TIME_COLUMN_TEMPLATE;
 
-public class Aggregator {
-  private final Accumulator accumulator;
+public class TableAggregator {
+  private final TableAccumulator accumulator;
   private final AggregationNode.Step step;
   private final TSDataType outputType;
   private final int[] inputChannels;
   private final OptionalInt maskChannel;
 
-  public Aggregator(
-      Accumulator accumulator,
+  public TableAggregator(
+      TableAccumulator accumulator,
       AggregationNode.Step step,
       TSDataType outputType,
       List<Integer> inputChannels,
@@ -80,6 +81,16 @@ public class Aggregator {
     }
   }
 
+  /** Used for AggregateTableScanOperator. */
+  public void processStatistics(Statistics statistics) {
+    checkArgument(inputChannels.length == 1, "expected 1 input channel for processStatistics");
+    accumulator.addStatistics(statistics);
+  }
+
+  public boolean hasFinalResult() {
+    return accumulator.hasFinalResult();
+  }
+
   public void reset() {
     accumulator.reset();
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/ConditionWindowManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/ConditionWindowManager.java
index 70d251ef461..2804c80535a 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/ConditionWindowManager.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/ConditionWindowManager.java
@@ -21,7 +21,7 @@ package org.apache.iotdb.db.queryengine.execution.operator.window;
 
 import org.apache.iotdb.db.queryengine.execution.aggregation.AccumulatorFactory;
 import org.apache.iotdb.db.queryengine.execution.aggregation.AccumulatorFactory.KeepEvaluator;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 
 import org.apache.tsfile.block.column.Column;
 import org.apache.tsfile.enums.TSDataType;
@@ -162,7 +162,7 @@ public class ConditionWindowManager implements IWindowManager {
   }
 
   @Override
-  public TsBlockBuilder createResultTsBlockBuilder(List<Aggregator> aggregators) {
+  public TsBlockBuilder createResultTsBlockBuilder(List<TreeAggregator> aggregators) {
     List<TSDataType> dataTypes = getResultDataTypes(aggregators);
     // Judge whether we need output endTime column.
     if (conditionWindow.isOutputEndTime()) {
@@ -173,7 +173,7 @@ public class ConditionWindowManager implements IWindowManager {
 
   @Override
   public void appendAggregationResult(
-      TsBlockBuilder resultTsBlockBuilder, List<Aggregator> aggregators) {
+      TsBlockBuilder resultTsBlockBuilder, List<TreeAggregator> aggregators) {
     if (!keepEvaluator.apply(conditionWindow.getKeep())) {
       return;
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/CountWindowManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/CountWindowManager.java
index 3b86e9b462c..b81dd5af1e5 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/CountWindowManager.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/CountWindowManager.java
@@ -19,7 +19,7 @@
 
 package org.apache.iotdb.db.queryengine.execution.operator.window;
 
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 
 import org.apache.tsfile.block.column.Column;
 import org.apache.tsfile.enums.TSDataType;
@@ -116,7 +116,7 @@ public class CountWindowManager implements IWindowManager {
   }
 
   @Override
-  public TsBlockBuilder createResultTsBlockBuilder(List<Aggregator> aggregators) {
+  public TsBlockBuilder createResultTsBlockBuilder(List<TreeAggregator> aggregators) {
     List<TSDataType> dataTypes = getResultDataTypes(aggregators);
     // Judge whether we need output endTime column.
     if (countWindow.isNeedOutputEndTime()) {
@@ -127,7 +127,7 @@ public class CountWindowManager implements IWindowManager {
 
   @Override
   public void appendAggregationResult(
-      TsBlockBuilder resultTsBlockBuilder, List<Aggregator> aggregators) {
+      TsBlockBuilder resultTsBlockBuilder, List<TreeAggregator> aggregators) {
     if (countWindow.getLeftCount() != 0) {
       return;
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/IWindowManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/IWindowManager.java
index c66a3bb725c..a1f32b7097d 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/IWindowManager.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/IWindowManager.java
@@ -19,7 +19,7 @@
 
 package org.apache.iotdb.db.queryengine.execution.operator.window;
 
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 
 import org.apache.tsfile.block.column.ColumnBuilder;
 import org.apache.tsfile.enums.TSDataType;
@@ -98,9 +98,9 @@ public interface IWindowManager {
    * @param aggregators the list of aggregators
    * @return Aggregation result column type list.
    */
-  default List<TSDataType> getResultDataTypes(List<Aggregator> aggregators) {
+  default List<TSDataType> getResultDataTypes(List<TreeAggregator> aggregators) {
     List<TSDataType> dataTypes = new ArrayList<>();
-    for (Aggregator aggregator : aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       dataTypes.addAll(Arrays.asList(aggregator.getOutputType()));
     }
     return dataTypes;
@@ -115,7 +115,7 @@ public interface IWindowManager {
    * @param aggregators the list of aggregators
    * @return TsBlockBuilder of resultSet
    */
-  TsBlockBuilder createResultTsBlockBuilder(List<Aggregator> aggregators);
+  TsBlockBuilder createResultTsBlockBuilder(List<TreeAggregator> aggregators);
 
   /**
    * Used to append a row of aggregation result into the resultSet.
@@ -127,7 +127,8 @@ public interface IWindowManager {
    * @param resultTsBlockBuilder tsBlockBuilder for resultSet
    * @param aggregators the list of aggregators
    */
-  void appendAggregationResult(TsBlockBuilder resultTsBlockBuilder, List<Aggregator> aggregators);
+  void appendAggregationResult(
+      TsBlockBuilder resultTsBlockBuilder, List<TreeAggregator> aggregators);
 
   /**
    * Especially for TimeWindow, if there are no points belong to last TimeWindow, the last
@@ -160,7 +161,7 @@ public interface IWindowManager {
    * @param endTime if the window doesn't need to output endTime, just assign -1 to endTime.
    */
   default void outputAggregators(
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       TsBlockBuilder resultTsBlockBuilder,
       long startTime,
       long endTime) {
@@ -173,7 +174,7 @@ public interface IWindowManager {
       columnBuilders[0].writeLong(endTime);
       columnIndex = 1;
     }
-    for (Aggregator aggregator : aggregators) {
+    for (TreeAggregator aggregator : aggregators) {
       ColumnBuilder[] columnBuilder = new ColumnBuilder[aggregator.getOutputType().length];
       columnBuilder[0] = columnBuilders[columnIndex++];
       if (columnBuilder.length > 1) {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/SessionWindowManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/SessionWindowManager.java
index cae70428af2..42ca3becedd 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/SessionWindowManager.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/SessionWindowManager.java
@@ -19,7 +19,7 @@
 
 package org.apache.iotdb.db.queryengine.execution.operator.window;
 
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 
 import org.apache.tsfile.block.column.Column;
 import org.apache.tsfile.enums.TSDataType;
@@ -126,7 +126,7 @@ public class SessionWindowManager implements IWindowManager {
   }
 
   @Override
-  public TsBlockBuilder createResultTsBlockBuilder(List<Aggregator> aggregators) {
+  public TsBlockBuilder createResultTsBlockBuilder(List<TreeAggregator> aggregators) {
     List<TSDataType> dataTypes = getResultDataTypes(aggregators);
     // Judge whether we need output endTime column.
     if (isNeedOutputEndTime) {
@@ -137,7 +137,7 @@ public class SessionWindowManager implements IWindowManager {
 
   @Override
   public void appendAggregationResult(
-      TsBlockBuilder resultTsBlockBuilder, List<Aggregator> aggregators) {
+      TsBlockBuilder resultTsBlockBuilder, List<TreeAggregator> aggregators) {
     long endTime = isNeedOutputEndTime ? sessionWindow.getEndTime() : -1;
     outputAggregators(aggregators, resultTsBlockBuilder, sessionWindow.getStartTime(), endTime);
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/TimeWindowManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/TimeWindowManager.java
index f5558e74fd4..9ecb42aec1f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/TimeWindowManager.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/TimeWindowManager.java
@@ -19,7 +19,7 @@
 
 package org.apache.iotdb.db.queryengine.execution.operator.window;
 
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
 import org.apache.iotdb.db.queryengine.execution.operator.AggregationUtil;
 
@@ -133,7 +133,7 @@ public class TimeWindowManager implements IWindowManager {
   }
 
   @Override
-  public TsBlockBuilder createResultTsBlockBuilder(List<Aggregator> aggregators) {
+  public TsBlockBuilder createResultTsBlockBuilder(List<TreeAggregator> aggregators) {
     List<TSDataType> dataTypes = getResultDataTypes(aggregators);
     // Judge whether we need output endTime column.
     if (this.needOutputEndTime) {
@@ -144,7 +144,7 @@ public class TimeWindowManager implements IWindowManager {
 
   @Override
   public void appendAggregationResult(
-      TsBlockBuilder resultTsBlockBuilder, List<Aggregator> aggregators) {
+      TsBlockBuilder resultTsBlockBuilder, List<TreeAggregator> aggregators) {
     outputAggregators(
         aggregators,
         resultTsBlockBuilder,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/VariationWindowManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/VariationWindowManager.java
index a4e1fecbc37..5c9ef777379 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/VariationWindowManager.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/window/VariationWindowManager.java
@@ -19,7 +19,7 @@
 
 package org.apache.iotdb.db.queryengine.execution.operator.window;
 
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 
 import org.apache.tsfile.enums.TSDataType;
 import org.apache.tsfile.read.common.block.TsBlockBuilder;
@@ -78,7 +78,7 @@ public abstract class VariationWindowManager implements IWindowManager {
   }
 
   @Override
-  public TsBlockBuilder createResultTsBlockBuilder(List<Aggregator> aggregators) {
+  public TsBlockBuilder createResultTsBlockBuilder(List<TreeAggregator> aggregators) {
     List<TSDataType> dataTypes = getResultDataTypes(aggregators);
     // Judge whether we need output endTime column.
     if (variationWindow.isOutputEndTime()) {
@@ -88,7 +88,7 @@ public abstract class VariationWindowManager implements IWindowManager {
   }
 
   public void appendAggregationResult(
-      TsBlockBuilder resultTsBlockBuilder, List<Aggregator> aggregators) {
+      TsBlockBuilder resultTsBlockBuilder, List<TreeAggregator> aggregators) {
 
     long endTime = variationWindow.isOutputEndTime() ? variationWindow.getEndTime() : -1;
     outputAggregators(aggregators, resultTsBlockBuilder, variationWindow.getStartTime(), endTime);
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 b35b3073ba6..b6893731bc4 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
@@ -36,7 +36,7 @@ import org.apache.iotdb.db.queryengine.common.NodeRef;
 import org.apache.iotdb.db.queryengine.common.TimeseriesContext;
 import org.apache.iotdb.db.queryengine.execution.aggregation.Accumulator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.AccumulatorFactory;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.slidingwindow.SlidingWindowAggregatorFactory;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
 import org.apache.iotdb.db.queryengine.execution.driver.DataDriverContext;
@@ -622,11 +622,11 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
         (NonAlignedFullPath) IFullPath.convertToIFullPath(node.getSeriesPath());
     boolean ascending = node.getScanOrder() == ASC;
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     aggregationDescriptors.forEach(
         o ->
             aggregators.add(
-                new Aggregator(
+                new TreeAggregator(
                     AccumulatorFactory.createAccumulator(
                         o.getAggregationFuncName(),
                         o.getAggregationType(),
@@ -738,7 +738,7 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
       LocalExecutionPlanContext context) {
     AlignedFullPath seriesPath = (AlignedFullPath) IFullPath.convertToIFullPath(alignedPath);
     boolean ascending = scanOrder == ASC;
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     boolean canUseStatistics = true;
     for (AggregationDescriptor descriptor : aggregationDescriptorList) {
       checkArgument(
@@ -757,7 +757,7 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
           canUseStatistics = false;
         }
         aggregators.add(
-            new Aggregator(
+            new TreeAggregator(
                 AccumulatorFactory.createAccumulator(
                     descriptor.getAggregationFuncName(),
                     descriptor.getAggregationType(),
@@ -771,7 +771,7 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
                     new InputLocation[] {new InputLocation(0, seriesIndex)})));
       } else if (expression instanceof TimestampOperand) {
         aggregators.add(
-            new Aggregator(
+            new TreeAggregator(
                 AccumulatorFactory.createAccumulator(
                     descriptor.getAggregationFuncName(),
                     descriptor.getAggregationType(),
@@ -1812,7 +1812,7 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
         "GroupByLevel descriptorList cannot be empty");
     List<Operator> children = dealWithConsumeAllChildrenPipelineBreaker(node, context);
     boolean ascending = node.getScanOrder() == ASC;
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     Map<String, List<InputLocation>> layout = makeLayout(node);
     List<CrossSeriesAggregationDescriptor> aggregationDescriptors =
         node.getGroupByLevelDescriptors();
@@ -1829,7 +1829,7 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
                               descriptor.getInputExpressions().get(x).getExpressionString()))
               .collect(Collectors.toList());
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createAccumulator(
                   descriptor.getAggregationFuncName(),
                   descriptor.getAggregationType(),
@@ -1872,12 +1872,12 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
     boolean ascending = node.getScanOrder() == ASC;
     Map<String, List<InputLocation>> layout = makeLayout(node);
     List<List<String>> groups = new ArrayList<>();
-    List<List<Aggregator>> groupedAggregators = new ArrayList<>();
+    List<List<TreeAggregator>> groupedAggregators = new ArrayList<>();
     int aggregatorCount = 0;
     for (Map.Entry<List<String>, List<CrossSeriesAggregationDescriptor>> entry :
         node.getTagValuesToAggregationDescriptors().entrySet()) {
       groups.add(entry.getKey());
-      List<Aggregator> aggregators = new ArrayList<>();
+      List<TreeAggregator> aggregators = new ArrayList<>();
       for (CrossSeriesAggregationDescriptor aggregationDescriptor : entry.getValue()) {
         if (aggregationDescriptor == null) {
           aggregators.add(null);
@@ -1889,7 +1889,7 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
                 .map(x -> context.getTypeProvider().getTreeModelType(x.getExpressionString()))
                 .collect(Collectors.toList());
         aggregators.add(
-            new Aggregator(
+            new TreeAggregator(
                 AccumulatorFactory.createAccumulator(
                     aggregationDescriptor.getAggregationFuncName(),
                     aggregationDescriptor.getAggregationType(),
@@ -1943,7 +1943,7 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
                 SlidingWindowAggregationOperator.class.getSimpleName());
     Operator child = node.getChild().accept(this, context);
     boolean ascending = node.getScanOrder() == ASC;
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     Map<String, List<InputLocation>> layout = makeLayout(node);
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
     for (AggregationDescriptor descriptor : aggregationDescriptors) {
@@ -2041,12 +2041,12 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
         "Aggregation descriptorList cannot be empty");
     Operator child = node.getChild().accept(this, context);
     boolean ascending = node.getScanOrder() == ASC;
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
     for (AggregationDescriptor descriptor : node.getAggregationDescriptorList()) {
       List<InputLocation[]> inputLocationList = calcInputLocationList(descriptor, layout);
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createAccumulator(
                   descriptor.getAggregationFuncName(),
                   descriptor.getAggregationType(),
@@ -2166,13 +2166,13 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
         "Aggregation descriptorList cannot be empty");
     List<Operator> children = dealWithConsumeAllChildrenPipelineBreaker(node, context);
     boolean ascending = node.getScanOrder() == ASC;
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> 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);
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createAccumulator(
                   descriptor.getAggregationFuncName(),
                   descriptor.getAggregationType(),
@@ -2945,7 +2945,7 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
                 SeriesAggregationScanOperator.class.getSimpleName());
 
     // last_time, last_value
-    List<Aggregator> aggregators = LastQueryUtil.createAggregators(seriesPath.getSeriesType());
+    List<TreeAggregator> aggregators = LastQueryUtil.createAggregators(seriesPath.getSeriesType());
     ITimeRangeIterator timeRangeIterator = initTimeRangeIterator(null, false, false);
     long maxReturnSize = calculateMaxAggregationResultSizeForLastQuery(aggregators);
 
@@ -2977,7 +2977,7 @@ public class OperatorTreeGenerator extends PlanVisitor<Operator, LocalExecutionP
       AlignedFullPath unCachedPath,
       LocalExecutionPlanContext context) {
     // last_time, last_value
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     boolean canUseStatistics = true;
     for (int i = 0; i < unCachedPath.getMeasurementList().size(); i++) {
       TSDataType dataType = unCachedPath.getSchemaList().get(i).getType();
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TableOperatorGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TableOperatorGenerator.java
index 971e1c74470..934a5b539e1 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TableOperatorGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TableOperatorGenerator.java
@@ -24,6 +24,8 @@ import org.apache.iotdb.commons.path.AlignedFullPath;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.queryengine.common.FragmentInstanceId;
 import org.apache.iotdb.db.queryengine.common.header.ColumnHeader;
+import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.SingleTimeWindowIterator;
 import org.apache.iotdb.db.queryengine.execution.driver.DataDriverContext;
 import org.apache.iotdb.db.queryengine.execution.exchange.MPPDataExchangeManager;
 import org.apache.iotdb.db.queryengine.execution.exchange.MPPDataExchangeService;
@@ -61,12 +63,13 @@ import org.apache.iotdb.db.queryengine.execution.operator.schema.source.SchemaSo
 import org.apache.iotdb.db.queryengine.execution.operator.sink.IdentitySinkOperator;
 import org.apache.iotdb.db.queryengine.execution.operator.source.AlignedSeriesScanOperator;
 import org.apache.iotdb.db.queryengine.execution.operator.source.ExchangeOperator;
+import org.apache.iotdb.db.queryengine.execution.operator.source.relational.TableAggregationTableScanOperator;
 import org.apache.iotdb.db.queryengine.execution.operator.source.relational.TableFullOuterJoinOperator;
 import org.apache.iotdb.db.queryengine.execution.operator.source.relational.TableInnerJoinOperator;
 import org.apache.iotdb.db.queryengine.execution.operator.source.relational.TableScanOperator;
-import org.apache.iotdb.db.queryengine.execution.operator.source.relational.aggregation.Accumulator;
 import org.apache.iotdb.db.queryengine.execution.operator.source.relational.aggregation.AggregationOperator;
-import org.apache.iotdb.db.queryengine.execution.operator.source.relational.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.operator.source.relational.aggregation.TableAccumulator;
+import org.apache.iotdb.db.queryengine.execution.operator.source.relational.aggregation.TableAggregator;
 import org.apache.iotdb.db.queryengine.execution.relational.ColumnTransformerBuilder;
 import org.apache.iotdb.db.queryengine.plan.analyze.TypeProvider;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
@@ -125,6 +128,7 @@ import com.google.common.collect.ImmutableMap;
 import org.apache.tsfile.common.conf.TSFileConfig;
 import org.apache.tsfile.common.conf.TSFileDescriptor;
 import org.apache.tsfile.enums.TSDataType;
+import org.apache.tsfile.read.common.type.BlobType;
 import org.apache.tsfile.read.common.type.RowType;
 import org.apache.tsfile.read.common.type.Type;
 import org.apache.tsfile.read.filter.basic.Filter;
@@ -152,6 +156,7 @@ import java.util.stream.Collectors;
 import static com.google.common.base.Preconditions.checkArgument;
 import static java.util.Objects.requireNonNull;
 import static org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory.MEASUREMENT;
+import static org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory.TIME;
 import static org.apache.iotdb.db.queryengine.common.DataNodeEndPoints.isSameNode;
 import static org.apache.iotdb.db.queryengine.execution.operator.process.join.merge.MergeSortComparator.getComparatorForTable;
 import static org.apache.iotdb.db.queryengine.execution.operator.source.relational.TableScanOperator.constructAlignedPath;
@@ -165,6 +170,8 @@ import static org.apache.iotdb.db.queryengine.plan.planner.OperatorTreeGenerator
 import static org.apache.iotdb.db.queryengine.plan.relational.metadata.TableBuiltinAggregationFunction.getAggregationTypeByFuncName;
 import static org.apache.iotdb.db.queryengine.plan.relational.planner.SortOrder.ASC_NULLS_LAST;
 import static org.apache.iotdb.db.queryengine.plan.relational.type.InternalTypeManager.getTSDataType;
+import static org.apache.iotdb.db.utils.constant.SqlConstant.FIRST;
+import static org.apache.iotdb.db.utils.constant.SqlConstant.LAST;
 
 /** This Visitor is responsible for transferring Table PlanNode Tree to Table Operator Tree. */
 public class TableOperatorGenerator extends PlanVisitor<Operator, LocalExecutionPlanContext> {
@@ -354,7 +361,6 @@ public class TableOperatorGenerator extends PlanVisitor<Operator, LocalExecution
             node.getPlanNodeId(),
             columnSchemas,
             columnsIndexArray,
-            measurementColumnCount,
             node.getDeviceEntries(),
             node.getScanOrder(),
             scanOptionsBuilder.build(),
@@ -1199,7 +1205,7 @@ public class TableOperatorGenerator extends PlanVisitor<Operator, LocalExecution
       AggregationNode node, Operator child, TypeProvider typeProvider, OperatorContext context) {
 
     Map<Symbol, AggregationNode.Aggregation> aggregationMap = node.getAggregations();
-    ImmutableList.Builder<Aggregator> aggregatorBuilder = new ImmutableList.Builder<>();
+    ImmutableList.Builder<TableAggregator> aggregatorBuilder = new ImmutableList.Builder<>();
     Map<Symbol, Integer> childLayout =
         makeLayoutFromOutputSymbols(node.getChild().getOutputSymbols());
 
@@ -1216,7 +1222,7 @@ public class TableOperatorGenerator extends PlanVisitor<Operator, LocalExecution
     return new AggregationOperator(context, child, aggregatorBuilder.build());
   }
 
-  private Aggregator buildAggregator(
+  private TableAggregator buildAggregator(
       Map<Symbol, Integer> childLayout,
       Symbol symbol,
       AggregationNode.Aggregation aggregation,
@@ -1238,7 +1244,7 @@ public class TableOperatorGenerator extends PlanVisitor<Operator, LocalExecution
     }
 
     String functionName = aggregation.getResolvedFunction().getSignature().getName();
-    Accumulator accumulator =
+    TableAccumulator accumulator =
         createAccumulator(
             functionName,
             getAggregationTypeByFuncName(functionName),
@@ -1247,7 +1253,7 @@ public class TableOperatorGenerator extends PlanVisitor<Operator, LocalExecution
             Collections.emptyMap(),
             true);
 
-    return new Aggregator(
+    return new TableAggregator(
         accumulator,
         step,
         getTSDataType(typeProvider.getTableModelType(symbol)),
@@ -1258,6 +1264,197 @@ public class TableOperatorGenerator extends PlanVisitor<Operator, LocalExecution
   @Override
   public Operator visitAggregationTableScan(
       AggregationTableScanNode node, LocalExecutionPlanContext context) {
-    throw new UnsupportedOperationException("Agg-BE not supported");
+
+    List<TableAggregator> aggregators = new ArrayList<>(node.getAggregations().size());
+    Map<Symbol, Integer> columnLayout = new HashMap<>(node.getAggregations().size());
+
+    int aggregationsCount = node.getAggregations().size();
+    int[] layoutArray = new int[aggregationsCount];
+    int channel = 0;
+    int idx = -1;
+    int measurementColumnCount = 0;
+    boolean canUseStatistic = true;
+    Map<Symbol, Integer> idAndAttributeColumnsIndexMap = node.getIdAndAttributeIndexMap();
+    Map<Symbol, ColumnSchema> columnSchemaMap = node.getAssignments();
+    List<ColumnSchema> columnSchemas = new ArrayList<>(aggregationsCount);
+    int[] columnsIndexArray = new int[aggregationsCount];
+    List<String> measurementColumnNames = new ArrayList<>();
+    List<IMeasurementSchema> measurementSchemas = new ArrayList<>();
+
+    List<ColumnSchema> groupingKeySchemas = null;
+    int[] groupingKeyIndex = null;
+    if (!node.getGroupingKeys().isEmpty()) {
+      groupingKeySchemas = new ArrayList<>(node.getGroupingKeys().size());
+      groupingKeyIndex = new int[node.getGroupingKeys().size()];
+      for (int i = 0; i < node.getGroupingKeys().size(); i++) {
+        Symbol groupingKey = node.getGroupingKeys().get(i);
+
+        checkArgument(
+            idAndAttributeColumnsIndexMap.containsKey(groupingKey),
+            "grouping key must be ID or Attribute in AggregationTableScan");
+        groupingKeySchemas.add(columnSchemaMap.get(groupingKey));
+        groupingKeyIndex[i] = idAndAttributeColumnsIndexMap.get(groupingKey);
+      }
+    }
+
+    // TODO test aggregation function which has more than one arguements
+    for (Map.Entry<Symbol, AggregationNode.Aggregation> entry : node.getAggregations().entrySet()) {
+      idx++;
+      Symbol symbol = Symbol.from(entry.getValue().getArguments().get(0));
+      ColumnSchema schema = requireNonNull(columnSchemaMap.get(symbol), symbol + " is null");
+
+      String funcName = entry.getValue().getResolvedFunction().getSignature().getName();
+      if (schema.getType().equals(BlobType.BLOB)
+          && (FIRST.equals(funcName) || LAST.equals(funcName))) {
+        // first/last aggregation with BLOB type can not use statistics
+        canUseStatistic = false;
+      }
+
+      switch (schema.getColumnCategory()) {
+        case ID:
+        case ATTRIBUTE:
+          if (columnLayout.containsKey(symbol)) {
+            columnsIndexArray[idx] = columnsIndexArray[columnLayout.get(symbol)];
+          } else {
+            columnsIndexArray[idx] =
+                requireNonNull(idAndAttributeColumnsIndexMap.get(symbol), symbol + " is null");
+            columnSchemas.add(schema);
+          }
+          break;
+        case MEASUREMENT:
+          if (columnLayout.containsKey(symbol)) {
+            columnsIndexArray[idx] = columnsIndexArray[columnLayout.get(symbol)];
+          } else {
+            columnsIndexArray[idx] = measurementColumnCount;
+            measurementColumnCount++;
+            measurementColumnNames.add(symbol.getName());
+            measurementSchemas.add(
+                new MeasurementSchema(schema.getName(), getTSDataType(schema.getType())));
+            columnSchemas.add(schema);
+          }
+          break;
+        case TIME:
+          if (columnLayout.containsKey(symbol)) {
+            columnsIndexArray[idx] = columnsIndexArray[columnLayout.get(symbol)];
+          } else {
+            columnsIndexArray[idx] = -1;
+            columnSchemas.add(schema);
+          }
+          break;
+        default:
+          throw new IllegalArgumentException(
+              "Unexpected column category: " + schema.getColumnCategory());
+      }
+
+      if (!columnLayout.containsKey(symbol)) {
+        layoutArray[idx] = channel;
+        columnLayout.put(symbol, channel++);
+      } else {
+        layoutArray[idx] = columnLayout.get(symbol);
+      }
+
+      aggregators.add(
+          buildAggregator(
+              columnLayout,
+              entry.getKey(),
+              entry.getValue(),
+              node.getStep(),
+              context.getTypeProvider()));
+    }
+
+    for (Map.Entry<Symbol, ColumnSchema> entry : node.getAssignments().entrySet()) {
+      if (!columnLayout.containsKey(entry.getKey())
+          && entry.getValue().getColumnCategory() == MEASUREMENT) {
+        measurementColumnCount++;
+        measurementColumnNames.add(entry.getKey().getName());
+        measurementSchemas.add(
+            new MeasurementSchema(
+                entry.getValue().getName(), getTSDataType(entry.getValue().getType())));
+      }
+    }
+
+    final OperatorContext operatorContext =
+        context
+            .getDriverContext()
+            .addOperatorContext(
+                context.getNextOperatorId(),
+                node.getPlanNodeId(),
+                AggregationTableScanNode.class.getSimpleName());
+    SeriesScanOptions.Builder scanOptionsBuilder =
+        node.getTimePredicate()
+            .map(timePredicate -> getSeriesScanOptionsBuilder(context, timePredicate))
+            .orElse(new SeriesScanOptions.Builder());
+    scanOptionsBuilder.withPushDownLimit(node.getPushDownLimit());
+    scanOptionsBuilder.withPushDownOffset(node.getPushDownOffset());
+    scanOptionsBuilder.withPushLimitToEachDevice(node.isPushLimitToEachDevice());
+    scanOptionsBuilder.withAllSensors(new HashSet<>(measurementColumnNames));
+    Expression pushDownPredicate = node.getPushDownPredicate();
+    if (pushDownPredicate != null) {
+      scanOptionsBuilder.withPushDownFilter(
+          convertPredicateToFilter(pushDownPredicate, measurementColumnNames, columnSchemaMap));
+    }
+    ITimeRangeIterator timeRangeIterator =
+        new SingleTimeWindowIterator(Long.MIN_VALUE, Long.MAX_VALUE);
+    TableAggregationTableScanOperator aggTableScanOperator =
+        new TableAggregationTableScanOperator(
+            node.getPlanNodeId(),
+            operatorContext,
+            columnSchemas,
+            columnsIndexArray,
+            node.getDeviceEntries(),
+            node.getScanOrder(),
+            scanOptionsBuilder.build(),
+            measurementColumnNames,
+            measurementSchemas,
+            TSFileDescriptor.getInstance().getConfig().getMaxTsBlockLineNumber(),
+            measurementColumnCount,
+            aggregators,
+            groupingKeySchemas,
+            groupingKeyIndex,
+            timeRangeIterator,
+            false,
+            null,
+            calculateMaxAggregationResultSize(),
+            canUseStatistic,
+            layoutArray);
+
+    ((DataDriverContext) context.getDriverContext()).addSourceOperator(aggTableScanOperator);
+
+    for (int i = 0, size = node.getDeviceEntries().size(); i < size; i++) {
+      AlignedFullPath alignedPath =
+          constructAlignedPath(
+              node.getDeviceEntries().get(i), measurementColumnNames, measurementSchemas);
+      ((DataDriverContext) context.getDriverContext()).addPath(alignedPath);
+    }
+
+    context.getDriverContext().setInputDriver(true);
+
+    return aggTableScanOperator;
+  }
+
+  public static long calculateMaxAggregationResultSize(
+      // List<? extends AggregationDescriptor> aggregationDescriptors,
+      // ITimeRangeIterator timeRangeIterator
+      ) {
+    // TODO perfect max aggregation result size logic
+    return TSFileDescriptor.getInstance().getConfig().getMaxTsBlockSizeInBytes();
+
+    //    long timeValueColumnsSizePerLine = TimeColumn.SIZE_IN_BYTES_PER_POSITION;
+    //    for (AggregationDescriptor descriptor : aggregationDescriptors) {
+    //      List<TSDataType> outPutDataTypes =
+    //              descriptor.getOutputColumnNames().stream()
+    //                      .map(typeProvider::getTableModelType)
+    //                      .collect(Collectors.toList());
+    //      for (TSDataType tsDataType : outPutDataTypes) {
+    //        timeValueColumnsSizePerLine += getOutputColumnSizePerLine(tsDataType);
+    //      }
+    //    }
+    //
+    //    return Math.min(
+    //            TSFileDescriptor.getInstance().getConfig().getMaxTsBlockSizeInBytes(),
+    //            Math.min(
+    //                    TSFileDescriptor.getInstance().getConfig().getMaxTsBlockLineNumber(),
+    //                    timeRangeIterator.getTotalIntervalNum())
+    //                    * timeValueColumnsSizePerLine);
   }
 }
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 16892825146..368717e0799 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
@@ -628,7 +628,7 @@ public class PlanGraphPrinter extends PlanVisitor<List<String>, PlanGraphPrinter
     boxValue.add(
         String.format(
             "RegionId: %s",
-            node.getRegionReplicaSet() == null
+            node.getRegionReplicaSet() == null || node.getRegionReplicaSet().getRegionId() == null
                 ? ""
                 : node.getRegionReplicaSet().getRegionId().getId()));
     return render(node, boxValue, context);
@@ -693,7 +693,7 @@ public class PlanGraphPrinter extends PlanVisitor<List<String>, PlanGraphPrinter
     boxValue.add(
         String.format(
             "RegionId: %s",
-            node.getRegionReplicaSet() == null
+            node.getRegionReplicaSet() == null || node.getRegionReplicaSet().getRegionId() == null
                 ? ""
                 : node.getRegionReplicaSet().getRegionId().getId()));
     return render(node, boxValue, context);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/function/BoundSignature.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/function/BoundSignature.java
index 6347209d722..e16ce6e549d 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/function/BoundSignature.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/function/BoundSignature.java
@@ -55,10 +55,6 @@ public class BoundSignature {
     return returnType;
   }
 
-  public int getArity() {
-    return argumentTypes.size();
-  }
-
   public Type getArgumentType(int index) {
     return argumentTypes.get(index);
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/TableBuiltinAggregationFunction.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/TableBuiltinAggregationFunction.java
index e56675e5f06..a2b7fe8d354 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/TableBuiltinAggregationFunction.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/TableBuiltinAggregationFunction.java
@@ -114,6 +114,7 @@ public enum TableBuiltinAggregationFunction {
     } else if (AVG.functionName.equalsIgnoreCase(name)) {
       return ImmutableList.of(DOUBLE, INT64);
     } else {
+      // TODO(beyyes) consider other aggregations which changed the result type
       return ImmutableList.copyOf(originalArgumentTypes);
     }
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/TableMetadataImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/TableMetadataImpl.java
index 43040121845..e6da4cfd518 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/TableMetadataImpl.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/TableMetadataImpl.java
@@ -561,6 +561,7 @@ public class TableMetadataImpl implements Metadata {
               String.format(
                   "Second argument of Aggregate functions [%s] should be orderable", functionName));
         }
+        break;
       case SqlConstant.FIRST_BY:
       case SqlConstant.LAST_BY:
       case SqlConstant.MAX_BY:
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableDistributedPlanGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableDistributedPlanGenerator.java
index cef978762ea..8e7efc63aab 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableDistributedPlanGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableDistributedPlanGenerator.java
@@ -378,6 +378,7 @@ public class TableDistributedPlanGenerator
                   node.getQualifiedObjectName().getDatabaseName(),
                   deviceEntry.getDeviceID(),
                   node.getTimeFilter());
+
       for (TRegionReplicaSet regionReplicaSet : regionReplicaSets) {
         TableScanNode tableScanNode =
             tableScanNodeMap.computeIfAbsent(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelTypeProviderExtractor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelTypeProviderExtractor.java
index 10bf1137b24..a0b1464a8b5 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelTypeProviderExtractor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelTypeProviderExtractor.java
@@ -25,6 +25,7 @@ import org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.ExchangeNo
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.sink.IdentitySinkNode;
 import org.apache.iotdb.db.queryengine.plan.relational.planner.Symbol;
 import org.apache.iotdb.db.queryengine.plan.relational.planner.node.AggregationNode;
+import org.apache.iotdb.db.queryengine.plan.relational.planner.node.AggregationTableScanNode;
 import org.apache.iotdb.db.queryengine.plan.relational.planner.node.CollectNode;
 import org.apache.iotdb.db.queryengine.plan.relational.planner.node.FillNode;
 import org.apache.iotdb.db.queryengine.plan.relational.planner.node.FilterNode;
@@ -73,6 +74,12 @@ public class TableModelTypeProviderExtractor {
 
     @Override
     public Void visitPlan(PlanNode node, Void context) {
+      addOutputSymbolsToTypeProvider(node);
+      node.getChildren().forEach(child -> child.accept(this, context));
+      return null;
+    }
+
+    private void addOutputSymbolsToTypeProvider(PlanNode node) {
       for (Symbol symbol : node.getOutputSymbols()) {
         if (!feTypeProvider.isSymbolExist(symbol)) {
           throw new IllegalStateException(
@@ -82,8 +89,6 @@ public class TableModelTypeProviderExtractor {
         }
         beTypeProvider.putTableModelType(symbol, feTypeProvider.getTableModelType(symbol));
       }
-      node.getChildren().forEach(child -> child.accept(this, context));
-      return null;
     }
 
     @Override
@@ -102,6 +107,13 @@ public class TableModelTypeProviderExtractor {
       return null;
     }
 
+    @Override
+    public Void visitAggregationTableScan(AggregationTableScanNode node, Void context) {
+      addOutputSymbolsToTypeProvider(node);
+      node.getAssignments().forEach((k, v) -> beTypeProvider.putTableModelType(k, v.getType()));
+      return null;
+    }
+
     @Override
     public Void visitTableScan(TableScanNode node, Void context) {
       node.getAssignments().forEach((k, v) -> beTypeProvider.putTableModelType(k, v.getType()));
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/node/AggregationTableScanNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/node/AggregationTableScanNode.java
index fe40770721a..0b61595d7e6 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/node/AggregationTableScanNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/node/AggregationTableScanNode.java
@@ -16,27 +16,34 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+
 package org.apache.iotdb.db.queryengine.plan.relational.planner.node;
 
+import org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeId;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeType;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanVisitor;
+import org.apache.iotdb.db.queryengine.plan.relational.function.BoundSignature;
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.ColumnSchema;
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.DeviceEntry;
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.QualifiedObjectName;
+import org.apache.iotdb.db.queryengine.plan.relational.metadata.ResolvedFunction;
 import org.apache.iotdb.db.queryengine.plan.relational.planner.Assignments;
 import org.apache.iotdb.db.queryengine.plan.relational.planner.Symbol;
 import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Expression;
+import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.SymbolReference;
 import org.apache.iotdb.db.queryengine.plan.statement.component.Ordering;
 
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
+import org.apache.tsfile.read.common.type.LongType;
+import org.apache.tsfile.read.common.type.TimestampType;
 import org.apache.tsfile.utils.ReadWriteIOUtils;
 
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -47,6 +54,8 @@ import java.util.Set;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static java.util.Objects.requireNonNull;
+import static org.apache.iotdb.db.utils.constant.SqlConstant.COUNT;
+import static org.apache.iotdb.db.utils.constant.SqlConstant.TABLE_TIME_COLUMN_NAME;
 
 public class AggregationTableScanNode extends TableScanNode {
   // if there is date_bin function of time, we should use this field to transform time input
@@ -92,7 +101,27 @@ public class AggregationTableScanNode extends TableScanNode {
         pushLimitToEachDevice);
     this.projection = projection;
 
-    this.aggregations = ImmutableMap.copyOf(requireNonNull(aggregations, "aggregations is null"));
+    this.aggregations = new LinkedHashMap<>(aggregations.size());
+    for (Map.Entry<Symbol, AggregationNode.Aggregation> entry : aggregations.entrySet()) {
+      Symbol symbol = entry.getKey();
+      AggregationNode.Aggregation aggregation = entry.getValue();
+      if (aggregation.getArguments().isEmpty()
+          && COUNT.equals(aggregation.getResolvedFunction().getSignature().getName())) {
+        AggregationNode.Aggregation countStarAggregation = getCountStarAggregation(aggregation);
+        if (!assignments.containsKey(Symbol.of(TABLE_TIME_COLUMN_NAME))) {
+          assignments.put(
+              Symbol.of(TABLE_TIME_COLUMN_NAME),
+              new ColumnSchema(
+                  TABLE_TIME_COLUMN_NAME,
+                  TimestampType.TIMESTAMP,
+                  false,
+                  TsTableColumnCategory.TIME));
+        }
+        this.aggregations.put(symbol, countStarAggregation);
+      } else {
+        this.aggregations.put(symbol, aggregation);
+      }
+    }
     aggregations.values().forEach(aggregation -> aggregation.verifyArguments(step));
 
     requireNonNull(groupingSets, "groupingSets is null");
@@ -129,6 +158,26 @@ public class AggregationTableScanNode extends TableScanNode {
     this.setOutputSymbols(outputs.build());
   }
 
+  private AggregationNode.Aggregation getCountStarAggregation(
+      AggregationNode.Aggregation aggregation) {
+    ResolvedFunction resolvedFunction = aggregation.getResolvedFunction();
+    ResolvedFunction countStarFunction =
+        new ResolvedFunction(
+            new BoundSignature(
+                COUNT, LongType.INT64, Collections.singletonList(TimestampType.TIMESTAMP)),
+            resolvedFunction.getFunctionId(),
+            resolvedFunction.getFunctionKind(),
+            resolvedFunction.isDeterministic(),
+            resolvedFunction.getFunctionNullability());
+    return new AggregationNode.Aggregation(
+        countStarFunction,
+        Collections.singletonList(new SymbolReference(TABLE_TIME_COLUMN_NAME)),
+        aggregation.isDistinct(),
+        aggregation.getFilter(),
+        aggregation.getOrderingScheme(),
+        aggregation.getMask());
+  }
+
   public Assignments getProjection() {
     return projection;
   }
@@ -335,10 +384,15 @@ public class AggregationTableScanNode extends TableScanNode {
     ReadWriteIOUtils.write(pushDownOffset, byteBuffer);
     ReadWriteIOUtils.write(pushLimitToEachDevice, byteBuffer);
 
-    ReadWriteIOUtils.write(projection.getMap().size(), byteBuffer);
-    for (Map.Entry<Symbol, Expression> entry : projection.getMap().entrySet()) {
-      Symbol.serialize(entry.getKey(), byteBuffer);
-      Expression.serialize(entry.getValue(), byteBuffer);
+    if (projection != null) {
+      ReadWriteIOUtils.write(true, byteBuffer);
+      ReadWriteIOUtils.write(projection.getMap().size(), byteBuffer);
+      for (Map.Entry<Symbol, Expression> entry : projection.getMap().entrySet()) {
+        Symbol.serialize(entry.getKey(), byteBuffer);
+        Expression.serialize(entry.getValue(), byteBuffer);
+      }
+    } else {
+      ReadWriteIOUtils.write(false, byteBuffer);
     }
 
     ReadWriteIOUtils.write(aggregations.size(), byteBuffer);
@@ -410,10 +464,15 @@ public class AggregationTableScanNode extends TableScanNode {
     ReadWriteIOUtils.write(pushDownOffset, stream);
     ReadWriteIOUtils.write(pushLimitToEachDevice, stream);
 
-    ReadWriteIOUtils.write(projection.getMap().size(), stream);
-    for (Map.Entry<Symbol, Expression> entry : projection.getMap().entrySet()) {
-      Symbol.serialize(entry.getKey(), stream);
-      Expression.serialize(entry.getValue(), stream);
+    if (projection != null) {
+      ReadWriteIOUtils.write(true, stream);
+      ReadWriteIOUtils.write(projection.getMap().size(), stream);
+      for (Map.Entry<Symbol, Expression> entry : projection.getMap().entrySet()) {
+        Symbol.serialize(entry.getKey(), stream);
+        Expression.serialize(entry.getValue(), stream);
+      }
+    } else {
+      ReadWriteIOUtils.write(false, stream);
     }
 
     ReadWriteIOUtils.write(aggregations.size(), stream);
@@ -447,7 +506,7 @@ public class AggregationTableScanNode extends TableScanNode {
     QualifiedObjectName qualifiedObjectName = new QualifiedObjectName(databaseName, tableName);
 
     int size = ReadWriteIOUtils.readInt(byteBuffer);
-    Map<Symbol, ColumnSchema> assignments = new HashMap<>(size);
+    Map<Symbol, ColumnSchema> assignments = new LinkedHashMap<>(size);
     for (int i = 0; i < size; i++) {
       assignments.put(Symbol.deserialize(byteBuffer), ColumnSchema.deserialize(byteBuffer));
     }
@@ -483,10 +542,13 @@ public class AggregationTableScanNode extends TableScanNode {
     long pushDownOffset = ReadWriteIOUtils.readLong(byteBuffer);
     boolean pushLimitToEachDevice = ReadWriteIOUtils.readBool(byteBuffer);
 
-    size = ReadWriteIOUtils.readInt(byteBuffer);
     Assignments.Builder projection = Assignments.builder();
-    while (size-- > 0) {
-      projection.put(Symbol.deserialize(byteBuffer), Expression.deserialize(byteBuffer));
+    boolean hasProjection = ReadWriteIOUtils.readBool(byteBuffer);
+    if (hasProjection) {
+      size = ReadWriteIOUtils.readInt(byteBuffer);
+      while (size-- > 0) {
+        projection.put(Symbol.deserialize(byteBuffer), Expression.deserialize(byteBuffer));
+      }
     }
 
     size = ReadWriteIOUtils.readInt(byteBuffer);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PushPredicateIntoTableScan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PushPredicateIntoTableScan.java
index d70ce7e0b8f..9db2f87cfd9 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PushPredicateIntoTableScan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PushPredicateIntoTableScan.java
@@ -1,15 +1,20 @@
 /*
- * Licensed 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
+ * 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
+ *      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.
+ * 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.relational.planner.optimizations;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/Util.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/Util.java
index 34965df3987..cdd8f01ab12 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/Util.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/Util.java
@@ -1,15 +1,20 @@
 /*
- * Licensed 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
+ * 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.
+ * 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.relational.planner.optimizations;
@@ -39,6 +44,8 @@ import static org.apache.iotdb.db.queryengine.plan.relational.planner.node.Aggre
 import static org.apache.iotdb.db.queryengine.plan.relational.planner.node.AggregationNode.Step.SINGLE;
 
 public class Util {
+  private Util() {}
+
   /**
    * Split AggregationNode into two-stage.
    *
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/constant/SqlConstant.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/constant/SqlConstant.java
index 541bf90ec85..b30ae505e13 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/constant/SqlConstant.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/constant/SqlConstant.java
@@ -31,7 +31,7 @@ public class SqlConstant {
   private static final String[] SINGLE_ROOT_ARRAY = {"root", "**"};
   private static final String[] SINGLE_TIME_ARRAY = {"time"};
   public static final PartialPath TIME_PATH = new PartialPath(SINGLE_TIME_ARRAY);
-  public static final String RESERVED_TIME = "time";
+  public static final String TABLE_TIME_COLUMN_NAME = "time";
   public static final String NOW_FUNC = "now()";
 
   public static final String ROOT = "root";
@@ -60,6 +60,7 @@ public class SqlConstant {
   public static final String FIRST = "first";
   public static final String FIRST_BY = "first_by";
   public static final String LAST_BY = "last_by";
+  public static final String LAST = "last";
   public static final String COUNT = "count";
   public static final String AVG = "avg";
   public static final String SUM = "sum";
@@ -79,8 +80,6 @@ public class SqlConstant {
   // names of scalar functions
   public static final String DIFF = "diff";
 
-  public static final String LAST = "last";
-
   public static final String CAST_FUNCTION = "CAST";
   public static final String CAST_TYPE = "type";
   public static final String ROUND_FUNCTION = "ROUND";
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/AggregationOperatorTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/AggregationOperatorTest.java
index f52eeb29b21..1993aee0a78 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/AggregationOperatorTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/AggregationOperatorTest.java
@@ -29,7 +29,7 @@ import org.apache.iotdb.db.queryengine.common.PlanFragmentId;
 import org.apache.iotdb.db.queryengine.common.QueryId;
 import org.apache.iotdb.db.queryengine.execution.aggregation.Accumulator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.AccumulatorFactory;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.driver.DriverContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceStateMachine;
@@ -325,14 +325,14 @@ public class AggregationOperatorTest {
         new NonAlignedFullPath(
             IDeviceID.Factory.DEFAULT_FACTORY.create(AGGREGATION_OPERATOR_TEST_SG + ".device0"),
             new MeasurementSchema("sensor0", TSDataType.INT32));
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.PARTIAL)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.PARTIAL)));
 
     SeriesScanOptions.Builder scanOptionsBuilder = new SeriesScanOptions.Builder();
     scanOptionsBuilder.withAllSensors(Collections.singleton("sensor0"));
@@ -387,7 +387,7 @@ public class AggregationOperatorTest {
     children.add(seriesAggregationScanOperator1);
     children.add(seriesAggregationScanOperator2);
 
-    List<Aggregator> finalAggregators = new ArrayList<>();
+    List<TreeAggregator> finalAggregators = new ArrayList<>();
     List<Accumulator> accumulators =
         AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
@@ -397,7 +397,7 @@ public class AggregationOperatorTest {
             true);
     for (int i = 0; i < accumulators.size(); i++) {
       finalAggregators.add(
-          new Aggregator(accumulators.get(i), AggregationStep.FINAL, inputLocations.get(i)));
+          new TreeAggregator(accumulators.get(i), AggregationStep.FINAL, inputLocations.get(i)));
     }
 
     return new AggregationOperator(
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/AlignedSeriesAggregationScanOperatorTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/AlignedSeriesAggregationScanOperatorTest.java
index 52adcccd0d7..2f38887e78e 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/AlignedSeriesAggregationScanOperatorTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/AlignedSeriesAggregationScanOperatorTest.java
@@ -28,7 +28,7 @@ import org.apache.iotdb.db.queryengine.common.FragmentInstanceId;
 import org.apache.iotdb.db.queryengine.common.PlanFragmentId;
 import org.apache.iotdb.db.queryengine.common.QueryId;
 import org.apache.iotdb.db.queryengine.execution.aggregation.AccumulatorFactory;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.driver.DriverContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceStateMachine;
@@ -101,13 +101,13 @@ public class AlignedSeriesAggregationScanOperatorTest {
 
   @Test
   public void testAggregationWithoutTimeFilter() throws Exception {
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     for (int i = 0; i < measurementSchemas.size(); i++) {
       TSDataType dataType = measurementSchemas.get(i).getType();
       List<InputLocation[]> inputLocations = new ArrayList<>();
       inputLocations.add(new InputLocation[] {new InputLocation(0, i)});
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createBuiltinAccumulator(
                   TAggregationType.COUNT,
                   Collections.singletonList(dataType),
@@ -132,13 +132,13 @@ public class AlignedSeriesAggregationScanOperatorTest {
 
   @Test
   public void testAggregationWithoutTimeFilterOrderByTimeDesc() throws Exception {
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     for (int i = 0; i < measurementSchemas.size(); i++) {
       TSDataType dataType = measurementSchemas.get(i).getType();
       List<InputLocation[]> inputLocations = new ArrayList<>();
       inputLocations.add(new InputLocation[] {new InputLocation(0, i)});
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createBuiltinAccumulator(
                   TAggregationType.COUNT,
                   Collections.singletonList(dataType),
@@ -168,13 +168,13 @@ public class AlignedSeriesAggregationScanOperatorTest {
     aggregationTypes.add(TAggregationType.COUNT);
     aggregationTypes.add(TAggregationType.SUM);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     for (int i = 0; i < 2; i++) {
       TSDataType dataType = measurementSchemas.get(i).getType();
       List<InputLocation[]> inputLocations = new ArrayList<>();
       inputLocations.add(new InputLocation[] {new InputLocation(0, i)});
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createBuiltinAccumulator(
                   aggregationTypes.get(i),
                   Collections.singletonList(dataType),
@@ -206,13 +206,13 @@ public class AlignedSeriesAggregationScanOperatorTest {
     aggregationTypes.add(TAggregationType.MIN_TIME);
     aggregationTypes.add(TAggregationType.MAX_TIME);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     for (int i = 0; i < 6; i++) {
       TSDataType dataType = measurementSchemas.get(i).getType();
       List<InputLocation[]> inputLocations = new ArrayList<>();
       inputLocations.add(new InputLocation[] {new InputLocation(0, i)});
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createBuiltinAccumulator(
                   aggregationTypes.get(i),
                   Collections.singletonList(dataType),
@@ -248,13 +248,13 @@ public class AlignedSeriesAggregationScanOperatorTest {
     aggregationTypes.add(TAggregationType.MIN_TIME);
     aggregationTypes.add(TAggregationType.MAX_TIME);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     for (int i = 0; i < 6; i++) {
       TSDataType dataType = measurementSchemas.get(i).getType();
       List<InputLocation[]> inputLocations = new ArrayList<>();
       inputLocations.add(new InputLocation[] {new InputLocation(0, i)});
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createBuiltinAccumulator(
                   aggregationTypes.get(i),
                   Collections.singletonList(dataType),
@@ -282,13 +282,13 @@ public class AlignedSeriesAggregationScanOperatorTest {
 
   @Test
   public void testAggregationWithTimeFilter1() throws Exception {
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     for (int i = 0; i < measurementSchemas.size(); i++) {
       TSDataType dataType = measurementSchemas.get(i).getType();
       List<InputLocation[]> inputLocations = new ArrayList<>();
       inputLocations.add(new InputLocation[] {new InputLocation(0, i)});
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createBuiltinAccumulator(
                   TAggregationType.COUNT,
                   Collections.singletonList(dataType),
@@ -316,13 +316,13 @@ public class AlignedSeriesAggregationScanOperatorTest {
   @Test
   public void testAggregationWithTimeFilter2() throws Exception {
     Filter timeFilter = TimeFilterApi.ltEq(379);
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     for (int i = 0; i < measurementSchemas.size(); i++) {
       TSDataType dataType = measurementSchemas.get(i).getType();
       List<InputLocation[]> inputLocations = new ArrayList<>();
       inputLocations.add(new InputLocation[] {new InputLocation(0, i)});
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createBuiltinAccumulator(
                   TAggregationType.COUNT,
                   Collections.singletonList(dataType),
@@ -349,13 +349,13 @@ public class AlignedSeriesAggregationScanOperatorTest {
   @Test
   public void testAggregationWithTimeFilter3() throws Exception {
     Filter timeFilter = FilterFactory.and(TimeFilterApi.gtEq(100), TimeFilterApi.ltEq(399));
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     for (int i = 0; i < measurementSchemas.size(); i++) {
       TSDataType dataType = measurementSchemas.get(i).getType();
       List<InputLocation[]> inputLocations = new ArrayList<>();
       inputLocations.add(new InputLocation[] {new InputLocation(0, i)});
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createBuiltinAccumulator(
                   TAggregationType.COUNT,
                   Collections.singletonList(dataType),
@@ -388,13 +388,13 @@ public class AlignedSeriesAggregationScanOperatorTest {
     aggregationTypes.add(TAggregationType.MIN_TIME);
     aggregationTypes.add(TAggregationType.MAX_TIME);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     for (int i = 0; i < 6; i++) {
       TSDataType dataType = measurementSchemas.get(i).getType();
       List<InputLocation[]> inputLocations = new ArrayList<>();
       inputLocations.add(new InputLocation[] {new InputLocation(0, i)});
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createBuiltinAccumulator(
                   aggregationTypes.get(i),
                   Collections.singletonList(dataType),
@@ -427,13 +427,13 @@ public class AlignedSeriesAggregationScanOperatorTest {
     int[] result = new int[] {100, 100, 100, 99};
     GroupByTimeParameter groupByTimeParameter =
         new GroupByTimeParameter(0, 399, new TimeDuration(0, 100), new TimeDuration(0, 100), true);
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     for (int i = 0; i < measurementSchemas.size(); i++) {
       TSDataType dataType = measurementSchemas.get(i).getType();
       List<InputLocation[]> inputLocations = new ArrayList<>();
       inputLocations.add(new InputLocation[] {new InputLocation(0, i)});
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createBuiltinAccumulator(
                   TAggregationType.COUNT,
                   Collections.singletonList(dataType),
@@ -467,13 +467,13 @@ public class AlignedSeriesAggregationScanOperatorTest {
     Filter timeFilter = FilterFactory.and(TimeFilterApi.gtEq(120), TimeFilterApi.ltEq(379));
     GroupByTimeParameter groupByTimeParameter =
         new GroupByTimeParameter(0, 399, new TimeDuration(0, 100), new TimeDuration(0, 100), true);
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     for (int i = 0; i < measurementSchemas.size(); i++) {
       TSDataType dataType = measurementSchemas.get(i).getType();
       List<InputLocation[]> inputLocations = new ArrayList<>();
       inputLocations.add(new InputLocation[] {new InputLocation(0, i)});
       aggregators.add(
-          new Aggregator(
+          new TreeAggregator(
               AccumulatorFactory.createBuiltinAccumulator(
                   TAggregationType.COUNT,
                   Collections.singletonList(dataType),
@@ -518,7 +518,7 @@ public class AlignedSeriesAggregationScanOperatorTest {
     GroupByTimeParameter groupByTimeParameter =
         new GroupByTimeParameter(0, 399, new TimeDuration(0, 100), new TimeDuration(0, 100), true);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     List<InputLocation[]> inputLocations =
         Collections.singletonList(new InputLocation[] {new InputLocation(0, 1)});
     AccumulatorFactory.createBuiltinAccumulators(
@@ -527,7 +527,8 @@ public class AlignedSeriesAggregationScanOperatorTest {
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE, inputLocations)));
+        .forEach(
+            o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE, inputLocations)));
     AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
         initAlignedSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
@@ -563,7 +564,7 @@ public class AlignedSeriesAggregationScanOperatorTest {
     GroupByTimeParameter groupByTimeParameter =
         new GroupByTimeParameter(0, 399, new TimeDuration(0, 100), new TimeDuration(0, 100), true);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     List<InputLocation[]> inputLocations =
         Collections.singletonList(new InputLocation[] {new InputLocation(0, 1)});
     AccumulatorFactory.createBuiltinAccumulators(
@@ -572,7 +573,8 @@ public class AlignedSeriesAggregationScanOperatorTest {
             Collections.emptyList(),
             Collections.emptyMap(),
             false)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE, inputLocations)));
+        .forEach(
+            o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE, inputLocations)));
     AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
         initAlignedSeriesAggregationScanOperator(aggregators, null, false, groupByTimeParameter);
     int count = 0;
@@ -598,7 +600,7 @@ public class AlignedSeriesAggregationScanOperatorTest {
         new GroupByTimeParameter(0, 399, new TimeDuration(0, 100), new TimeDuration(0, 50), true);
     List<TAggregationType> aggregationTypes = Collections.singletonList(TAggregationType.COUNT);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     List<InputLocation[]> inputLocations =
         Collections.singletonList(new InputLocation[] {new InputLocation(0, 1)});
     AccumulatorFactory.createBuiltinAccumulators(
@@ -607,7 +609,8 @@ public class AlignedSeriesAggregationScanOperatorTest {
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE, inputLocations)));
+        .forEach(
+            o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE, inputLocations)));
     AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
         initAlignedSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
@@ -630,7 +633,7 @@ public class AlignedSeriesAggregationScanOperatorTest {
     GroupByTimeParameter groupByTimeParameter =
         new GroupByTimeParameter(0, 149, new TimeDuration(0, 50), new TimeDuration(0, 30), true);
     List<TAggregationType> aggregationTypes = Collections.singletonList(TAggregationType.COUNT);
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     List<InputLocation[]> inputLocations =
         Collections.singletonList(new InputLocation[] {new InputLocation(0, 1)});
     AccumulatorFactory.createBuiltinAccumulators(
@@ -639,7 +642,8 @@ public class AlignedSeriesAggregationScanOperatorTest {
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE, inputLocations)));
+        .forEach(
+            o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE, inputLocations)));
     AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
         initAlignedSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
@@ -673,7 +677,7 @@ public class AlignedSeriesAggregationScanOperatorTest {
 
     GroupByTimeParameter groupByTimeParameter =
         new GroupByTimeParameter(0, 149, new TimeDuration(0, 50), new TimeDuration(0, 30), true);
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     List<InputLocation[]> inputLocations =
         Collections.singletonList(new InputLocation[] {new InputLocation(0, 1)});
     AccumulatorFactory.createBuiltinAccumulators(
@@ -682,7 +686,8 @@ public class AlignedSeriesAggregationScanOperatorTest {
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE, inputLocations)));
+        .forEach(
+            o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE, inputLocations)));
     AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
         initAlignedSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
@@ -702,7 +707,7 @@ public class AlignedSeriesAggregationScanOperatorTest {
   }
 
   public AlignedSeriesAggregationScanOperator initAlignedSeriesAggregationScanOperator(
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       Filter timeFilter,
       boolean ascending,
       GroupByTimeParameter groupByTimeParameter)
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/HorizontallyConcatOperatorTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/HorizontallyConcatOperatorTest.java
index a2cf16dbaef..498a7ddbdac 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/HorizontallyConcatOperatorTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/HorizontallyConcatOperatorTest.java
@@ -27,7 +27,7 @@ import org.apache.iotdb.db.queryengine.common.FragmentInstanceId;
 import org.apache.iotdb.db.queryengine.common.PlanFragmentId;
 import org.apache.iotdb.db.queryengine.common.QueryId;
 import org.apache.iotdb.db.queryengine.execution.aggregation.AccumulatorFactory;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.driver.DriverContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceStateMachine;
@@ -132,14 +132,14 @@ public class HorizontallyConcatOperatorTest {
           Arrays.asList(TAggregationType.COUNT, TAggregationType.SUM, TAggregationType.FIRST_VALUE);
       GroupByTimeParameter groupByTimeParameter =
           new GroupByTimeParameter(0, 10, new TimeDuration(0, 1), new TimeDuration(0, 1), true);
-      List<Aggregator> aggregators = new ArrayList<>();
+      List<TreeAggregator> aggregators = new ArrayList<>();
       AccumulatorFactory.createBuiltinAccumulators(
               aggregationTypes,
               TSDataType.INT32,
               Collections.emptyList(),
               Collections.emptyMap(),
               true)
-          .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+          .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
 
       SeriesScanOptions.Builder scanOptionsBuilder = new SeriesScanOptions.Builder();
       scanOptionsBuilder.withAllSensors(allSensors);
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/LastQueryOperatorTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/LastQueryOperatorTest.java
index 297fb4dca79..8a7711d1f4c 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/LastQueryOperatorTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/LastQueryOperatorTest.java
@@ -26,7 +26,7 @@ import org.apache.iotdb.commons.path.MeasurementPath;
 import org.apache.iotdb.db.queryengine.common.FragmentInstanceId;
 import org.apache.iotdb.db.queryengine.common.PlanFragmentId;
 import org.apache.iotdb.db.queryengine.common.QueryId;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.driver.DriverContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceStateMachine;
@@ -96,10 +96,10 @@ public class LastQueryOperatorTest {
   @Test
   public void testLastQueryOperator1() throws Exception {
     try {
-      List<Aggregator> aggregators1 = LastQueryUtil.createAggregators(TSDataType.INT32);
+      List<TreeAggregator> aggregators1 = LastQueryUtil.createAggregators(TSDataType.INT32);
       MeasurementPath measurementPath1 =
           new MeasurementPath(SERIES_SCAN_OPERATOR_TEST_SG + ".device0.sensor0", TSDataType.INT32);
-      List<Aggregator> aggregators2 = LastQueryUtil.createAggregators(TSDataType.INT32);
+      List<TreeAggregator> aggregators2 = LastQueryUtil.createAggregators(TSDataType.INT32);
       MeasurementPath measurementPath2 =
           new MeasurementPath(SERIES_SCAN_OPERATOR_TEST_SG + ".device0.sensor1", TSDataType.INT32);
       Set<String> allSensors = Sets.newHashSet("sensor0", "sensor1");
@@ -224,10 +224,10 @@ public class LastQueryOperatorTest {
   @Test
   public void testLastQueryOperator2() {
     try {
-      List<Aggregator> aggregators1 = LastQueryUtil.createAggregators(TSDataType.INT32);
+      List<TreeAggregator> aggregators1 = LastQueryUtil.createAggregators(TSDataType.INT32);
       MeasurementPath measurementPath1 =
           new MeasurementPath(SERIES_SCAN_OPERATOR_TEST_SG + ".device0.sensor0", TSDataType.INT32);
-      List<Aggregator> aggregators2 = LastQueryUtil.createAggregators(TSDataType.INT32);
+      List<TreeAggregator> aggregators2 = LastQueryUtil.createAggregators(TSDataType.INT32);
       MeasurementPath measurementPath2 =
           new MeasurementPath(SERIES_SCAN_OPERATOR_TEST_SG + ".device0.sensor1", TSDataType.INT32);
       Set<String> allSensors = Sets.newHashSet("sensor0", "sensor1");
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/LastQueryTreeSortOperatorTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/LastQueryTreeSortOperatorTest.java
index e7a187ce12f..29cd23bbb19 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/LastQueryTreeSortOperatorTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/LastQueryTreeSortOperatorTest.java
@@ -25,7 +25,7 @@ import org.apache.iotdb.commons.path.MeasurementPath;
 import org.apache.iotdb.db.queryengine.common.FragmentInstanceId;
 import org.apache.iotdb.db.queryengine.common.PlanFragmentId;
 import org.apache.iotdb.db.queryengine.common.QueryId;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.driver.DriverContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceStateMachine;
@@ -97,10 +97,10 @@ public class LastQueryTreeSortOperatorTest {
   @Test
   public void testLastQuerySortOperatorAsc() {
     try {
-      List<Aggregator> aggregators1 = LastQueryUtil.createAggregators(TSDataType.INT32);
+      List<TreeAggregator> aggregators1 = LastQueryUtil.createAggregators(TSDataType.INT32);
       MeasurementPath measurementPath1 =
           new MeasurementPath(SERIES_SCAN_OPERATOR_TEST_SG + ".device0.sensor0", TSDataType.INT32);
-      List<Aggregator> aggregators2 = LastQueryUtil.createAggregators(TSDataType.INT32);
+      List<TreeAggregator> aggregators2 = LastQueryUtil.createAggregators(TSDataType.INT32);
       MeasurementPath measurementPath2 =
           new MeasurementPath(SERIES_SCAN_OPERATOR_TEST_SG + ".device0.sensor1", TSDataType.INT32);
       Set<String> allSensors = Sets.newHashSet("sensor0", "sensor1");
@@ -225,10 +225,10 @@ public class LastQueryTreeSortOperatorTest {
   @Test
   public void testLastQuerySortOperatorDesc() {
     try {
-      List<Aggregator> aggregators1 = LastQueryUtil.createAggregators(TSDataType.INT32);
+      List<TreeAggregator> aggregators1 = LastQueryUtil.createAggregators(TSDataType.INT32);
       MeasurementPath measurementPath1 =
           new MeasurementPath(SERIES_SCAN_OPERATOR_TEST_SG + ".device0.sensor0", TSDataType.INT32);
-      List<Aggregator> aggregators2 = LastQueryUtil.createAggregators(TSDataType.INT32);
+      List<TreeAggregator> aggregators2 = LastQueryUtil.createAggregators(TSDataType.INT32);
       MeasurementPath measurementPath2 =
           new MeasurementPath(SERIES_SCAN_OPERATOR_TEST_SG + ".device0.sensor1", TSDataType.INT32);
       Set<String> allSensors = Sets.newHashSet("sensor0", "sensor1");
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/OperatorMemoryTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/OperatorMemoryTest.java
index 854cf798633..15b9163bdc8 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/OperatorMemoryTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/OperatorMemoryTest.java
@@ -30,7 +30,7 @@ import org.apache.iotdb.db.queryengine.common.FragmentInstanceId;
 import org.apache.iotdb.db.queryengine.common.PlanFragmentId;
 import org.apache.iotdb.db.queryengine.common.QueryId;
 import org.apache.iotdb.db.queryengine.execution.aggregation.AccumulatorFactory;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.timerangeiterator.ITimeRangeIterator;
 import org.apache.iotdb.db.queryengine.execution.driver.DriverContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceContext;
@@ -1193,11 +1193,11 @@ public class OperatorMemoryTest {
     PlanNodeId planNodeId = new PlanNodeId("1");
     driverContext.addOperatorContext(1, planNodeId, SeriesScanOperator.class.getSimpleName());
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     aggregationDescriptors.forEach(
         o ->
             aggregators.add(
-                new Aggregator(
+                new TreeAggregator(
                     AccumulatorFactory.createBuiltinAccumulator(
                         o.getAggregationType(),
                         Collections.singletonList(measurementPath.getSeriesType()),
@@ -1249,11 +1249,11 @@ public class OperatorMemoryTest {
                 AggregationStep.FINAL,
                 Collections.singletonList(new TimeSeriesOperand(measurementPath))));
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     aggregationDescriptors.forEach(
         o ->
             aggregators.add(
-                new Aggregator(
+                new TreeAggregator(
                     AccumulatorFactory.createBuiltinAccumulator(
                         o.getAggregationType(),
                         Collections.singletonList(measurementPath.getSeriesType()),
@@ -1322,11 +1322,11 @@ public class OperatorMemoryTest {
                 AggregationStep.FINAL,
                 Collections.singletonList(new TimeSeriesOperand(measurementPath))));
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     aggregationDescriptors.forEach(
         o ->
             aggregators.add(
-                new Aggregator(
+                new TreeAggregator(
                     AccumulatorFactory.createBuiltinAccumulator(
                         o.getAggregationType(),
                         Collections.singletonList(measurementPath.getSeriesType()),
@@ -1402,11 +1402,11 @@ public class OperatorMemoryTest {
                 AggregationStep.FINAL,
                 Collections.singletonList(new TimeSeriesOperand(measurementPath))));
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     aggregationDescriptors.forEach(
         o ->
             aggregators.add(
-                new Aggregator(
+                new TreeAggregator(
                     AccumulatorFactory.createBuiltinAccumulator(
                         o.getAggregationType(),
                         Collections.singletonList(measurementPath.getSeriesType()),
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/RawDataAggregationOperatorTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/RawDataAggregationOperatorTest.java
index 163d2692e40..0410265bcea 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/RawDataAggregationOperatorTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/RawDataAggregationOperatorTest.java
@@ -30,7 +30,7 @@ import org.apache.iotdb.db.queryengine.common.PlanFragmentId;
 import org.apache.iotdb.db.queryengine.common.QueryId;
 import org.apache.iotdb.db.queryengine.execution.aggregation.Accumulator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.AccumulatorFactory;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.driver.DriverContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceStateMachine;
@@ -980,7 +980,7 @@ public class RawDataAggregationOperatorTest {
                 new SingleColumnMerger(new InputLocation(1, 0), new AscTimeComparator())),
             new AscTimeComparator());
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     List<Accumulator> accumulators =
         AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
@@ -990,7 +990,7 @@ public class RawDataAggregationOperatorTest {
             true);
     for (int i = 0; i < accumulators.size(); i++) {
       aggregators.add(
-          new Aggregator(accumulators.get(i), AggregationStep.SINGLE, inputLocations.get(i)));
+          new TreeAggregator(accumulators.get(i), AggregationStep.SINGLE, inputLocations.get(i)));
     }
     return new RawDataAggregationOperator(
         driverContext.getOperatorContexts().get(3),
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/SeriesAggregationScanOperatorTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/SeriesAggregationScanOperatorTest.java
index 343b53490db..42ddfcf64bb 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/SeriesAggregationScanOperatorTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/SeriesAggregationScanOperatorTest.java
@@ -27,7 +27,7 @@ import org.apache.iotdb.db.queryengine.common.FragmentInstanceId;
 import org.apache.iotdb.db.queryengine.common.PlanFragmentId;
 import org.apache.iotdb.db.queryengine.common.QueryId;
 import org.apache.iotdb.db.queryengine.execution.aggregation.AccumulatorFactory;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.driver.DriverContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceStateMachine;
@@ -99,14 +99,14 @@ public class SeriesAggregationScanOperatorTest {
   @Test
   public void testAggregationWithoutTimeFilter() throws Exception {
     List<TAggregationType> aggregationTypes = Collections.singletonList(TAggregationType.COUNT);
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, null, true, null);
     int count = 0;
@@ -123,14 +123,14 @@ public class SeriesAggregationScanOperatorTest {
   @Test
   public void testAggregationWithoutTimeFilterOrderByTimeDesc() throws Exception {
     List<TAggregationType> aggregationTypes = Collections.singletonList(TAggregationType.COUNT);
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, null, false, null);
     int count = 0;
@@ -149,14 +149,14 @@ public class SeriesAggregationScanOperatorTest {
     List<TAggregationType> aggregationTypes = new ArrayList<>();
     aggregationTypes.add(TAggregationType.COUNT);
     aggregationTypes.add(TAggregationType.SUM);
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, null, true, null);
     int count = 0;
@@ -180,14 +180,14 @@ public class SeriesAggregationScanOperatorTest {
     aggregationTypes.add(TAggregationType.MAX_TIME);
     aggregationTypes.add(TAggregationType.MAX_VALUE);
     aggregationTypes.add(TAggregationType.MIN_VALUE);
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, null, true, null);
     int count = 0;
@@ -216,14 +216,14 @@ public class SeriesAggregationScanOperatorTest {
     aggregationTypes.add(TAggregationType.MAX_VALUE);
     aggregationTypes.add(TAggregationType.MIN_VALUE);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             false)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, null, false, null);
     int count = 0;
@@ -246,14 +246,14 @@ public class SeriesAggregationScanOperatorTest {
   public void testAggregationWithTimeFilter1() throws Exception {
     List<TAggregationType> aggregationTypes = Collections.singletonList(TAggregationType.COUNT);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     Filter timeFilter = TimeFilterApi.gtEq(120);
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
@@ -273,14 +273,14 @@ public class SeriesAggregationScanOperatorTest {
     Filter timeFilter = TimeFilterApi.ltEq(379);
     List<TAggregationType> aggregationTypes = Collections.singletonList(TAggregationType.COUNT);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
     int count = 0;
@@ -299,14 +299,14 @@ public class SeriesAggregationScanOperatorTest {
     Filter timeFilter = FilterFactory.and(TimeFilterApi.gtEq(100), TimeFilterApi.ltEq(399));
     List<TAggregationType> aggregationTypes = Collections.singletonList(TAggregationType.COUNT);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
     int count = 0;
@@ -330,14 +330,14 @@ public class SeriesAggregationScanOperatorTest {
     aggregationTypes.add(TAggregationType.MAX_VALUE);
     aggregationTypes.add(TAggregationType.MIN_VALUE);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     Filter timeFilter = FilterFactory.and(TimeFilterApi.gtEq(100), TimeFilterApi.ltEq(399));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
@@ -363,14 +363,14 @@ public class SeriesAggregationScanOperatorTest {
     GroupByTimeParameter groupByTimeParameter =
         new GroupByTimeParameter(0, 399, new TimeDuration(0, 100), new TimeDuration(0, 100), true);
     List<TAggregationType> aggregationTypes = Collections.singletonList(TAggregationType.COUNT);
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
@@ -396,14 +396,14 @@ public class SeriesAggregationScanOperatorTest {
         new GroupByTimeParameter(0, 399, new TimeDuration(0, 100), new TimeDuration(0, 100), true);
     List<TAggregationType> aggregationTypes = Collections.singletonList(TAggregationType.COUNT);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, timeFilter, true, groupByTimeParameter);
     int count = 0;
@@ -438,14 +438,14 @@ public class SeriesAggregationScanOperatorTest {
     GroupByTimeParameter groupByTimeParameter =
         new GroupByTimeParameter(0, 399, new TimeDuration(0, 100), new TimeDuration(0, 100), true);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
@@ -483,14 +483,14 @@ public class SeriesAggregationScanOperatorTest {
     GroupByTimeParameter groupByTimeParameter =
         new GroupByTimeParameter(0, 399, new TimeDuration(0, 100), new TimeDuration(0, 100), true);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             false)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, null, false, groupByTimeParameter);
     int count = 0;
@@ -518,14 +518,14 @@ public class SeriesAggregationScanOperatorTest {
         new GroupByTimeParameter(0, 399, new TimeDuration(0, 100), new TimeDuration(0, 50), true);
     List<TAggregationType> aggregationTypes = Collections.singletonList(TAggregationType.COUNT);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
@@ -551,14 +551,14 @@ public class SeriesAggregationScanOperatorTest {
         new GroupByTimeParameter(0, 149, new TimeDuration(0, 50), new TimeDuration(0, 30), true);
     List<TAggregationType> aggregationTypes = Collections.singletonList(TAggregationType.COUNT);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
@@ -594,14 +594,14 @@ public class SeriesAggregationScanOperatorTest {
     GroupByTimeParameter groupByTimeParameter =
         new GroupByTimeParameter(0, 149, new TimeDuration(0, 50), new TimeDuration(0, 30), true);
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             aggregationTypes,
             TSDataType.INT32,
             Collections.emptyList(),
             Collections.emptyMap(),
             true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+        .forEach(o -> aggregators.add(new TreeAggregator(o, AggregationStep.SINGLE)));
     SeriesAggregationScanOperator seriesAggregationScanOperator =
         initSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
@@ -623,7 +623,7 @@ public class SeriesAggregationScanOperatorTest {
   }
 
   public SeriesAggregationScanOperator initSeriesAggregationScanOperator(
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       Filter timeFilter,
       boolean ascending,
       GroupByTimeParameter groupByTimeParameter)
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/SlidingWindowAggregationOperatorTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/SlidingWindowAggregationOperatorTest.java
index 2bdcb28957e..ec18f86716c 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/SlidingWindowAggregationOperatorTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/SlidingWindowAggregationOperatorTest.java
@@ -28,7 +28,7 @@ import org.apache.iotdb.db.queryengine.common.FragmentInstanceId;
 import org.apache.iotdb.db.queryengine.common.PlanFragmentId;
 import org.apache.iotdb.db.queryengine.common.QueryId;
 import org.apache.iotdb.db.queryengine.execution.aggregation.AccumulatorFactory;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.aggregation.slidingwindow.SlidingWindowAggregatorFactory;
 import org.apache.iotdb.db.queryengine.execution.driver.DriverContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceContext;
@@ -241,7 +241,7 @@ public class SlidingWindowAggregationOperatorTest {
             IDeviceID.Factory.DEFAULT_FACTORY.create(AGGREGATION_OPERATOR_TEST_SG + ".device0"),
             new MeasurementSchema("sensor0", TSDataType.INT32));
 
-    List<Aggregator> aggregators = new ArrayList<>();
+    List<TreeAggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createBuiltinAccumulators(
             leafAggregationTypes,
             TSDataType.INT32,
@@ -249,7 +249,8 @@ public class SlidingWindowAggregationOperatorTest {
             Collections.emptyMap(),
             ascending)
         .forEach(
-            accumulator -> aggregators.add(new Aggregator(accumulator, AggregationStep.PARTIAL)));
+            accumulator ->
+                aggregators.add(new TreeAggregator(accumulator, AggregationStep.PARTIAL)));
 
     SeriesScanOptions.Builder scanOptionsBuilder = new SeriesScanOptions.Builder();
     scanOptionsBuilder.withAllSensors(Collections.singleton("sensor0"));
@@ -268,7 +269,7 @@ public class SlidingWindowAggregationOperatorTest {
     seriesAggregationScanOperator.initQueryDataSource(
         new QueryDataSource(seqResources, unSeqResources));
 
-    List<Aggregator> finalAggregators = new ArrayList<>();
+    List<TreeAggregator> finalAggregators = new ArrayList<>();
     for (int i = 0; i < rootAggregationTypes.size(); i++) {
       finalAggregators.add(
           SlidingWindowAggregatorFactory.createSlidingWindowAggregator(
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/UpdateLastCacheOperatorTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/UpdateLastCacheOperatorTest.java
index d991caff54b..1cd55520985 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/UpdateLastCacheOperatorTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/execution/operator/UpdateLastCacheOperatorTest.java
@@ -26,7 +26,7 @@ import org.apache.iotdb.commons.path.MeasurementPath;
 import org.apache.iotdb.db.queryengine.common.FragmentInstanceId;
 import org.apache.iotdb.db.queryengine.common.PlanFragmentId;
 import org.apache.iotdb.db.queryengine.common.QueryId;
-import org.apache.iotdb.db.queryengine.execution.aggregation.Aggregator;
+import org.apache.iotdb.db.queryengine.execution.aggregation.TreeAggregator;
 import org.apache.iotdb.db.queryengine.execution.driver.DriverContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceStateMachine;
@@ -97,7 +97,7 @@ public class UpdateLastCacheOperatorTest {
   @Test
   public void testUpdateLastCacheOperatorTestWithoutTimeFilter() {
     try {
-      List<Aggregator> aggregators = LastQueryUtil.createAggregators(TSDataType.INT32);
+      List<TreeAggregator> aggregators = LastQueryUtil.createAggregators(TSDataType.INT32);
       UpdateLastCacheOperator updateLastCacheOperator =
           initUpdateLastCacheOperator(aggregators, null, false, null);
 
@@ -126,7 +126,7 @@ public class UpdateLastCacheOperatorTest {
   @Test
   public void testUpdateLastCacheOperatorTestWithTimeFilter1() {
     try {
-      List<Aggregator> aggregators = LastQueryUtil.createAggregators(TSDataType.INT32);
+      List<TreeAggregator> aggregators = LastQueryUtil.createAggregators(TSDataType.INT32);
       Filter timeFilter = TimeFilterApi.gtEq(200);
       UpdateLastCacheOperator updateLastCacheOperator =
           initUpdateLastCacheOperator(aggregators, timeFilter, false, null);
@@ -156,7 +156,7 @@ public class UpdateLastCacheOperatorTest {
   @Test
   public void testUpdateLastCacheOperatorTestWithTimeFilter2() {
     try {
-      List<Aggregator> aggregators = LastQueryUtil.createAggregators(TSDataType.INT32);
+      List<TreeAggregator> aggregators = LastQueryUtil.createAggregators(TSDataType.INT32);
       Filter timeFilter = TimeFilterApi.ltEq(120);
       UpdateLastCacheOperator updateLastCacheOperator =
           initUpdateLastCacheOperator(aggregators, timeFilter, false, null);
@@ -184,7 +184,7 @@ public class UpdateLastCacheOperatorTest {
   }
 
   public UpdateLastCacheOperator initUpdateLastCacheOperator(
-      List<Aggregator> aggregators,
+      List<TreeAggregator> aggregators,
       Filter timeFilter,
       boolean ascending,
       GroupByTimeParameter groupByTimeParameter)