You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ja...@apache.org on 2022/05/20 06:10:39 UTC

[iotdb] branch master updated: [IOTDB-3222] Implementation of AlignedSeriesAggregateScanOperator (#5938)

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

jackietien 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 e8d61657b4 [IOTDB-3222] Implementation of AlignedSeriesAggregateScanOperator (#5938)
e8d61657b4 is described below

commit e8d61657b4f78ae45cae8ac8be2a085257e48991
Author: Xiangwei Wei <34...@users.noreply.github.com>
AuthorDate: Fri May 20 14:10:34 2022 +0800

    [IOTDB-3222] Implementation of AlignedSeriesAggregateScanOperator (#5938)
---
 .../iotdb/db/mpp/aggregation/Aggregator.java       |  12 +-
 .../db/mpp/aggregation/FirstValueAccumulator.java  |   3 +
 .../db/mpp/aggregation/LastValueAccumulator.java   |   3 +
 ...egateOperator.java => AggregationOperator.java} |   8 +-
 ...erator.java => RawDataAggregationOperator.java} |  10 +-
 ...a => AlignedSeriesAggregationScanOperator.java} | 184 ++++-----
 ...tor.java => SeriesAggregationScanOperator.java} |  26 +-
 .../db/mpp/plan/planner/LocalExecutionPlanner.java |  59 ++-
 .../db/mpp/plan/planner/plan/node/PlanVisitor.java |   2 +-
 .../source/AlignedSeriesAggregationScanNode.java   |   6 +-
 .../groupby/impl/LocalAlignedGroupByExecutor.java  |   2 -
 ...ratorTest.java => AggregationOperatorTest.java} |  70 ++--
 ... AlignedSeriesAggregationScanOperatorTest.java} | 436 +++++++++++++--------
 ...st.java => RawDataAggregationOperatorTest.java} |  50 +--
 ...java => SeriesAggregationScanOperatorTest.java} | 146 ++++---
 15 files changed, 572 insertions(+), 445 deletions(-)

diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/Aggregator.java b/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/Aggregator.java
index 6077648e59..b9ccc4c7b3 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/Aggregator.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/Aggregator.java
@@ -60,7 +60,6 @@ public class Aggregator {
     checkArgument(
         step.isInputRaw(),
         "Step in SeriesAggregateScanOperator and RawDataAggregateOperator can only process raw input");
-    // TODO Aligned TimeSeries
     if (inputLocationList == null) {
       accumulator.addInput(tsBlock.getTimeAndValueColumn(0), timeRange);
     } else {
@@ -110,6 +109,17 @@ public class Aggregator {
     accumulator.addStatistics(statistics);
   }
 
+  /** Used for AlignedSeriesAggregateScanOperator. */
+  public void processStatistics(Statistics[] statistics) {
+    for (InputLocation[] inputLocations : inputLocationList) {
+      checkArgument(
+          inputLocations[0].getTsBlockIndex() == 0,
+          "AlignedSeriesAggregateScanOperator can only process one tsBlock input.");
+      int valueIndex = inputLocations[0].getValueColumnIndex();
+      accumulator.addStatistics(statistics[valueIndex]);
+    }
+  }
+
   public TSDataType[] getOutputType() {
     if (step.isOutputPartial()) {
       return accumulator.getIntermediateType();
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/FirstValueAccumulator.java b/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/FirstValueAccumulator.java
index ac0f4a423f..f4537fbd62 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/FirstValueAccumulator.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/FirstValueAccumulator.java
@@ -63,6 +63,7 @@ public class FirstValueAccumulator implements Accumulator {
         break;
       case BOOLEAN:
         addBooleanInput(column, timeRange);
+        break;
       default:
         throw new UnSupportedDataTypeException(
             String.format("Unsupported data type in FirstValue: %s", seriesDataType));
@@ -118,8 +119,10 @@ public class FirstValueAccumulator implements Accumulator {
         break;
       case TEXT:
         updateBinaryFirstValue((Binary) statistics.getFirstValue(), statistics.getStartTime());
+        break;
       case BOOLEAN:
         updateBooleanFirstValue((boolean) statistics.getFirstValue(), statistics.getStartTime());
+        break;
       default:
         throw new UnSupportedDataTypeException(
             String.format("Unsupported data type in FirstValue: %s", seriesDataType));
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/LastValueAccumulator.java b/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/LastValueAccumulator.java
index b884af9d56..bea0fb6d04 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/LastValueAccumulator.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/aggregation/LastValueAccumulator.java
@@ -63,6 +63,7 @@ public class LastValueAccumulator implements Accumulator {
         break;
       case BOOLEAN:
         addBooleanInput(column, timeRange);
+        break;
       default:
         throw new UnSupportedDataTypeException(
             String.format("Unsupported data type in LastValue: %s", seriesDataType));
@@ -118,8 +119,10 @@ public class LastValueAccumulator implements Accumulator {
         break;
       case TEXT:
         updateBinaryLastValue((Binary) statistics.getLastValue(), statistics.getEndTime());
+        break;
       case BOOLEAN:
         updateBooleanLastValue((boolean) statistics.getLastValue(), statistics.getEndTime());
+        break;
       default:
         throw new UnSupportedDataTypeException(
             String.format("Unsupported data type in LastValue: %s", seriesDataType));
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/AggregateOperator.java b/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/AggregationOperator.java
similarity index 95%
rename from server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/AggregateOperator.java
rename to server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/AggregationOperator.java
index c860cd7450..23ba0d1b57 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/AggregateOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/AggregationOperator.java
@@ -36,14 +36,14 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-import static org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregateScanOperator.initTimeRangeIterator;
+import static org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregationScanOperator.initTimeRangeIterator;
 
 /**
- * AggregateOperator can process the situation: aggregation of intermediate aggregate result, it
+ * AggregationOperator can process the situation: aggregation of intermediate aggregate result, it
  * will output one result based on time interval. One intermediate tsBlock input will only contain
  * the result of one time interval exactly.
  */
-public class AggregateOperator implements ProcessOperator {
+public class AggregationOperator implements ProcessOperator {
 
   private final OperatorContext operatorContext;
   private final List<Aggregator> aggregators;
@@ -57,7 +57,7 @@ public class AggregateOperator implements ProcessOperator {
   // current interval of aggregation window [curStartTime, curEndTime)
   private TimeRange curTimeRange;
 
-  public AggregateOperator(
+  public AggregationOperator(
       OperatorContext operatorContext,
       List<Aggregator> aggregators,
       List<Operator> children,
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/RawDataAggregateOperator.java b/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/RawDataAggregationOperator.java
similarity index 95%
rename from server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/RawDataAggregateOperator.java
rename to server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/RawDataAggregationOperator.java
index 45f376eaa2..fa724b12ab 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/RawDataAggregateOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/RawDataAggregationOperator.java
@@ -36,10 +36,10 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-import static org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregateScanOperator.initTimeRangeIterator;
+import static org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregationScanOperator.initTimeRangeIterator;
 
 /**
- * RawDataAggregateOperator is used to process raw data tsBlock input calculating using value
+ * RawDataAggregationOperator is used to process raw data tsBlock input calculating using value
  * filter. It's possible that there is more than one tsBlock input in one time interval. And it's
  * also possible that one tsBlock can cover multiple time intervals too.
  *
@@ -48,7 +48,7 @@ import static org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregateS
  *
  * <p>Return aggregation result in one time interval once.
  */
-public class RawDataAggregateOperator implements ProcessOperator {
+public class RawDataAggregationOperator implements ProcessOperator {
 
   private final OperatorContext operatorContext;
   private final List<Aggregator> aggregators;
@@ -63,7 +63,7 @@ public class RawDataAggregateOperator implements ProcessOperator {
   // Using for building result tsBlock
   private final TsBlockBuilder tsBlockBuilder;
 
-  public RawDataAggregateOperator(
+  public RawDataAggregationOperator(
       OperatorContext operatorContext,
       List<Aggregator> aggregators,
       Operator child,
@@ -111,7 +111,7 @@ public class RawDataAggregateOperator implements ProcessOperator {
     }
 
     // 3. Update result using aggregators
-    return AggregateOperator.updateResultTsBlockFromAggregators(
+    return AggregationOperator.updateResultTsBlockFromAggregators(
         tsBlockBuilder, aggregators, timeRangeIterator);
   }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/SeriesAggregateScanOperator.java b/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/AlignedSeriesAggregationScanOperator.java
similarity index 68%
copy from server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/SeriesAggregateScanOperator.java
copy to server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/AlignedSeriesAggregationScanOperator.java
index 92010c87ec..9ef84c165d 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/SeriesAggregateScanOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/AlignedSeriesAggregationScanOperator.java
@@ -16,16 +16,15 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+
 package org.apache.iotdb.db.mpp.execution.operator.source;
 
-import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.db.engine.querycontext.QueryDataSource;
+import org.apache.iotdb.db.metadata.path.AlignedPath;
 import org.apache.iotdb.db.mpp.aggregation.Aggregator;
 import org.apache.iotdb.db.mpp.aggregation.timerangeiterator.ITimeRangeIterator;
-import org.apache.iotdb.db.mpp.aggregation.timerangeiterator.SingleTimeWindowIterator;
-import org.apache.iotdb.db.mpp.aggregation.timerangeiterator.TimeRangeIteratorFactory;
 import org.apache.iotdb.db.mpp.execution.operator.OperatorContext;
-import org.apache.iotdb.db.mpp.execution.operator.process.AggregateOperator;
+import org.apache.iotdb.db.mpp.execution.operator.process.AggregationOperator;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.PlanNodeId;
 import org.apache.iotdb.db.mpp.plan.planner.plan.parameter.GroupByTimeParameter;
 import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
@@ -36,32 +35,25 @@ import org.apache.iotdb.tsfile.read.common.block.TsBlock.TsBlockSingleColumnIter
 import org.apache.iotdb.tsfile.read.common.block.TsBlockBuilder;
 import org.apache.iotdb.tsfile.read.filter.basic.Filter;
 
-import com.google.common.util.concurrent.ListenableFuture;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 
-import static org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregateOperator.isEndCalc;
-import static org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregateOperator.skipOutOfTimeRangePoints;
+import static org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregationOperator.isEndCalc;
+import static org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregationOperator.skipOutOfTimeRangePoints;
+import static org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregationScanOperator.initTimeRangeIterator;
 
-/**
- * This operator is responsible to do the aggregation calculation for one series based on global
- * time range and time split parameter.
- *
- * <p>Every time next() is invoked, one tsBlock which contains current time window will be returned.
- * In sliding window situation, current time window is a pre-aggregation window. If there is no time
- * split parameter, i.e. aggregation without groupBy, just one tsBlock will be returned.
- */
-public class SeriesAggregateScanOperator implements DataSourceOperator {
+/** This operator is responsible to do the aggregation calculation especially for aligned series. */
+public class AlignedSeriesAggregationScanOperator implements DataSourceOperator {
 
   private final OperatorContext operatorContext;
   private final PlanNodeId sourceId;
-  private final SeriesScanUtil seriesScanUtil;
+  private final AlignedSeriesScanUtil alignedSeriesScanUtil;
+  private final int subSensorSize;
   private final boolean ascending;
-  // We still think aggregator in SeriesAggregateScanOperator is a inputRaw step.
+  // We still think aggregator in AlignedSeriesAggregateScanOperator is a inputRaw step.
   // But in facing of statistics, it will invoke another method processStatistics()
   private List<Aggregator> aggregators;
 
@@ -76,10 +68,9 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
   private boolean hasCachedTsBlock = false;
   private boolean finished = false;
 
-  public SeriesAggregateScanOperator(
+  public AlignedSeriesAggregationScanOperator(
       PlanNodeId sourceId,
-      PartialPath seriesPath,
-      Set<String> allSensors,
+      AlignedPath seriesPath,
       OperatorContext context,
       List<Aggregator> aggregators,
       Filter timeFilter,
@@ -88,15 +79,15 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
     this.sourceId = sourceId;
     this.operatorContext = context;
     this.ascending = ascending;
-    this.seriesScanUtil =
-        new SeriesScanUtil(
+    this.alignedSeriesScanUtil =
+        new AlignedSeriesScanUtil(
             seriesPath,
-            allSensors,
-            seriesPath.getSeriesType(),
+            new HashSet<>(seriesPath.getMeasurementList()),
             context.getInstanceContext(),
             timeFilter,
             null,
             ascending);
+    this.subSensorSize = seriesPath.getMeasurementList().size();
     this.aggregators = aggregators;
     List<TSDataType> dataTypes = new ArrayList<>();
     for (Aggregator aggregator : aggregators) {
@@ -106,40 +97,11 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
     this.timeRangeIterator = initTimeRangeIterator(groupByTimeParameter, ascending);
   }
 
-  /**
-   * If groupByTimeParameter is null, which means it's an aggregation query without down sampling.
-   * Aggregation query has only one time window and the result set of it does not contain a
-   * timestamp, so it doesn't matter what the time range returns.
-   */
-  public static ITimeRangeIterator initTimeRangeIterator(
-      GroupByTimeParameter groupByTimeParameter, boolean ascending) {
-    if (groupByTimeParameter == null) {
-      return new SingleTimeWindowIterator(0, Long.MAX_VALUE);
-    } else {
-      return TimeRangeIteratorFactory.getTimeRangeIterator(
-          groupByTimeParameter.getStartTime(),
-          groupByTimeParameter.getEndTime(),
-          groupByTimeParameter.getInterval(),
-          groupByTimeParameter.getSlidingStep(),
-          ascending,
-          groupByTimeParameter.isIntervalByMonth(),
-          groupByTimeParameter.isSlidingStepByMonth(),
-          groupByTimeParameter.isLeftCRightO(),
-          groupByTimeParameter.getInterval() > groupByTimeParameter.getSlidingStep());
-    }
-  }
-
   @Override
   public OperatorContext getOperatorContext() {
     return operatorContext;
   }
 
-  // TODO
-  @Override
-  public ListenableFuture<Void> isBlocked() {
-    return DataSourceOperator.super.isBlocked();
-  }
-
   @Override
   public TsBlock next() {
     if (hasCachedTsBlock || hasNext()) {
@@ -185,22 +147,27 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
       }
 
       // read from file first
-      while (seriesScanUtil.hasNextFile()) {
-        Statistics fileStatistics = seriesScanUtil.currentFileStatistics();
-        if (fileStatistics.getStartTime() > curTimeRange.getMax()) {
+      while (alignedSeriesScanUtil.hasNextFile()) {
+        Statistics fileTimeStatistics = alignedSeriesScanUtil.currentFileTimeStatistics();
+        if (fileTimeStatistics.getStartTime() > curTimeRange.getMax()) {
           if (ascending) {
             updateResultTsBlockFromAggregators();
             return true;
           } else {
-            seriesScanUtil.skipCurrentFile();
+            alignedSeriesScanUtil.skipCurrentFile();
             continue;
           }
         }
         // calc from fileMetaData
         if (canUseCurrentFileStatistics()
-            && curTimeRange.contains(fileStatistics.getStartTime(), fileStatistics.getEndTime())) {
-          calcFromStatistics(fileStatistics);
-          seriesScanUtil.skipCurrentFile();
+            && curTimeRange.contains(
+                fileTimeStatistics.getStartTime(), fileTimeStatistics.getEndTime())) {
+          Statistics[] statisticsList = new Statistics[subSensorSize];
+          for (int i = 0; i < subSensorSize; i++) {
+            statisticsList[i] = alignedSeriesScanUtil.currentFileStatistics(i);
+          }
+          calcFromStatistics(statisticsList);
+          alignedSeriesScanUtil.skipCurrentFile();
           continue;
         }
 
@@ -218,22 +185,14 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
     }
   }
 
-  private void updateResultTsBlockFromAggregators() {
-    resultTsBlock =
-        AggregateOperator.updateResultTsBlockFromAggregators(
-            tsBlockBuilder, aggregators, timeRangeIterator);
-    hasCachedTsBlock = true;
-  }
-
-  // TODO Implement it later?
   @Override
-  public void close() throws Exception {
-    DataSourceOperator.super.close();
+  public boolean isFinished() {
+    return finished || (finished = !hasNext());
   }
 
   @Override
-  public boolean isFinished() {
-    return finished || (finished = !hasNext());
+  public void initQueryDataSource(QueryDataSource dataSource) {
+    alignedSeriesScanUtil.initQueryDataSource(dataSource);
   }
 
   @Override
@@ -241,9 +200,11 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
     return sourceId;
   }
 
-  @Override
-  public void initQueryDataSource(QueryDataSource dataSource) {
-    seriesScanUtil.initQueryDataSource(dataSource);
+  private void updateResultTsBlockFromAggregators() {
+    resultTsBlock =
+        AggregationOperator.updateResultTsBlockFromAggregators(
+            tsBlockBuilder, aggregators, timeRangeIterator);
+    hasCachedTsBlock = true;
   }
 
   /** @return if already get the result */
@@ -253,7 +214,7 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
     return (preCachedData != null
             && (ascending
                 ? preCachedData.getEndTime() > curTimeRange.getMax()
-                : preCachedData.getEndTime() < curTimeRange.getMin()))
+                : preCachedData.getStartTime() < curTimeRange.getMin()))
         || isEndCalc(aggregators);
   }
 
@@ -304,24 +265,29 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
 
   @SuppressWarnings("squid:S3776") // Suppress high Cognitive Complexity warning
   private boolean readAndCalcFromPage(TimeRange curTimeRange) throws IOException {
-    while (seriesScanUtil.hasNextPage()) {
-      Statistics pageStatistics = seriesScanUtil.currentPageStatistics();
+    while (alignedSeriesScanUtil.hasNextPage()) {
+      Statistics pageTimeStatistics = alignedSeriesScanUtil.currentPageTimeStatistics();
       // must be non overlapped page
-      if (pageStatistics != null) {
+      if (pageTimeStatistics != null) {
         // There is no more eligible points in current time range
-        if (pageStatistics.getStartTime() > curTimeRange.getMax()) {
+        if (pageTimeStatistics.getStartTime() > curTimeRange.getMax()) {
           if (ascending) {
             return true;
           } else {
-            seriesScanUtil.skipCurrentPage();
+            alignedSeriesScanUtil.skipCurrentPage();
             continue;
           }
         }
         // can use pageHeader
         if (canUseCurrentPageStatistics()
-            && curTimeRange.contains(pageStatistics.getStartTime(), pageStatistics.getEndTime())) {
-          calcFromStatistics(pageStatistics);
-          seriesScanUtil.skipCurrentPage();
+            && curTimeRange.contains(
+                pageTimeStatistics.getStartTime(), pageTimeStatistics.getEndTime())) {
+          Statistics[] statisticsList = new Statistics[subSensorSize];
+          for (int i = 0; i < subSensorSize; i++) {
+            statisticsList[i] = alignedSeriesScanUtil.currentPageStatistics(i);
+          }
+          calcFromStatistics(statisticsList);
+          alignedSeriesScanUtil.skipCurrentPage();
           if (isEndCalc(aggregators)) {
             return true;
           }
@@ -330,7 +296,7 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
       }
 
       // calc from page data
-      TsBlock tsBlock = seriesScanUtil.nextPage();
+      TsBlock tsBlock = alignedSeriesScanUtil.nextPage();
       TsBlockSingleColumnIterator tsBlockIterator = tsBlock.getTsBlockSingleColumnIterator();
       if (tsBlockIterator == null || !tsBlockIterator.hasNext()) {
         continue;
@@ -361,21 +327,27 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
   }
 
   private boolean readAndCalcFromChunk(TimeRange curTimeRange) throws IOException {
-    while (seriesScanUtil.hasNextChunk()) {
-      Statistics chunkStatistics = seriesScanUtil.currentChunkStatistics();
-      if (chunkStatistics.getStartTime() > curTimeRange.getMax()) {
+    while (alignedSeriesScanUtil.hasNextChunk()) {
+      Statistics chunkTimeStatistics = alignedSeriesScanUtil.currentChunkTimeStatistics();
+      if (chunkTimeStatistics.getStartTime() > curTimeRange.getMax()) {
         if (ascending) {
           return true;
         } else {
-          seriesScanUtil.skipCurrentChunk();
+          alignedSeriesScanUtil.skipCurrentChunk();
           continue;
         }
       }
       // calc from chunkMetaData
       if (canUseCurrentChunkStatistics()
-          && curTimeRange.contains(chunkStatistics.getStartTime(), chunkStatistics.getEndTime())) {
-        calcFromStatistics(chunkStatistics);
-        seriesScanUtil.skipCurrentChunk();
+          && curTimeRange.contains(
+              chunkTimeStatistics.getStartTime(), chunkTimeStatistics.getEndTime())) {
+        // calc from chunkMetaData
+        Statistics[] statisticsList = new Statistics[subSensorSize];
+        for (int i = 0; i < subSensorSize; i++) {
+          statisticsList[i] = alignedSeriesScanUtil.currentChunkStatistics(i);
+        }
+        calcFromStatistics(statisticsList);
+        alignedSeriesScanUtil.skipCurrentChunk();
         continue;
       }
       // read page
@@ -386,7 +358,7 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
     return false;
   }
 
-  private void calcFromStatistics(Statistics statistics) {
+  private void calcFromStatistics(Statistics[] statistics) {
     for (int i = 0; i < aggregators.size(); i++) {
       Aggregator aggregator = aggregators.get(i);
       if (aggregator.hasFinalResult()) {
@@ -397,31 +369,31 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
   }
 
   public boolean canUseCurrentFileStatistics() throws IOException {
-    Statistics fileStatistics = seriesScanUtil.currentFileStatistics();
-    return !seriesScanUtil.isFileOverlapped()
+    Statistics fileStatistics = alignedSeriesScanUtil.currentFileTimeStatistics();
+    return !alignedSeriesScanUtil.isFileOverlapped()
         && containedByTimeFilter(fileStatistics)
-        && !seriesScanUtil.currentFileModified();
+        && !alignedSeriesScanUtil.currentFileModified();
   }
 
   public boolean canUseCurrentChunkStatistics() throws IOException {
-    Statistics chunkStatistics = seriesScanUtil.currentChunkStatistics();
-    return !seriesScanUtil.isChunkOverlapped()
+    Statistics chunkStatistics = alignedSeriesScanUtil.currentChunkTimeStatistics();
+    return !alignedSeriesScanUtil.isChunkOverlapped()
         && containedByTimeFilter(chunkStatistics)
-        && !seriesScanUtil.currentChunkModified();
+        && !alignedSeriesScanUtil.currentChunkModified();
   }
 
   public boolean canUseCurrentPageStatistics() throws IOException {
-    Statistics currentPageStatistics = seriesScanUtil.currentPageStatistics();
+    Statistics currentPageStatistics = alignedSeriesScanUtil.currentPageTimeStatistics();
     if (currentPageStatistics == null) {
       return false;
     }
-    return !seriesScanUtil.isPageOverlapped()
+    return !alignedSeriesScanUtil.isPageOverlapped()
         && containedByTimeFilter(currentPageStatistics)
-        && !seriesScanUtil.currentPageModified();
+        && !alignedSeriesScanUtil.currentPageModified();
   }
 
   private boolean containedByTimeFilter(Statistics statistics) {
-    Filter timeFilter = seriesScanUtil.getTimeFilter();
+    Filter timeFilter = alignedSeriesScanUtil.getTimeFilter();
     return timeFilter == null
         || timeFilter.containStartEndTime(statistics.getStartTime(), statistics.getEndTime());
   }
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/SeriesAggregateScanOperator.java b/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/SeriesAggregationScanOperator.java
similarity index 96%
rename from server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/SeriesAggregateScanOperator.java
rename to server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/SeriesAggregationScanOperator.java
index 92010c87ec..c234a7c2ef 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/SeriesAggregateScanOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/source/SeriesAggregationScanOperator.java
@@ -25,7 +25,7 @@ import org.apache.iotdb.db.mpp.aggregation.timerangeiterator.ITimeRangeIterator;
 import org.apache.iotdb.db.mpp.aggregation.timerangeiterator.SingleTimeWindowIterator;
 import org.apache.iotdb.db.mpp.aggregation.timerangeiterator.TimeRangeIteratorFactory;
 import org.apache.iotdb.db.mpp.execution.operator.OperatorContext;
-import org.apache.iotdb.db.mpp.execution.operator.process.AggregateOperator;
+import org.apache.iotdb.db.mpp.execution.operator.process.AggregationOperator;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.PlanNodeId;
 import org.apache.iotdb.db.mpp.plan.planner.plan.parameter.GroupByTimeParameter;
 import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
@@ -36,16 +36,14 @@ import org.apache.iotdb.tsfile.read.common.block.TsBlock.TsBlockSingleColumnIter
 import org.apache.iotdb.tsfile.read.common.block.TsBlockBuilder;
 import org.apache.iotdb.tsfile.read.filter.basic.Filter;
 
-import com.google.common.util.concurrent.ListenableFuture;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Set;
 
-import static org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregateOperator.isEndCalc;
-import static org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregateOperator.skipOutOfTimeRangePoints;
+import static org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregationOperator.isEndCalc;
+import static org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregationOperator.skipOutOfTimeRangePoints;
 
 /**
  * This operator is responsible to do the aggregation calculation for one series based on global
@@ -55,7 +53,7 @@ import static org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregat
  * In sliding window situation, current time window is a pre-aggregation window. If there is no time
  * split parameter, i.e. aggregation without groupBy, just one tsBlock will be returned.
  */
-public class SeriesAggregateScanOperator implements DataSourceOperator {
+public class SeriesAggregationScanOperator implements DataSourceOperator {
 
   private final OperatorContext operatorContext;
   private final PlanNodeId sourceId;
@@ -76,7 +74,7 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
   private boolean hasCachedTsBlock = false;
   private boolean finished = false;
 
-  public SeriesAggregateScanOperator(
+  public SeriesAggregationScanOperator(
       PlanNodeId sourceId,
       PartialPath seriesPath,
       Set<String> allSensors,
@@ -134,12 +132,6 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
     return operatorContext;
   }
 
-  // TODO
-  @Override
-  public ListenableFuture<Void> isBlocked() {
-    return DataSourceOperator.super.isBlocked();
-  }
-
   @Override
   public TsBlock next() {
     if (hasCachedTsBlock || hasNext()) {
@@ -220,17 +212,11 @@ public class SeriesAggregateScanOperator implements DataSourceOperator {
 
   private void updateResultTsBlockFromAggregators() {
     resultTsBlock =
-        AggregateOperator.updateResultTsBlockFromAggregators(
+        AggregationOperator.updateResultTsBlockFromAggregators(
             tsBlockBuilder, aggregators, timeRangeIterator);
     hasCachedTsBlock = true;
   }
 
-  // TODO Implement it later?
-  @Override
-  public void close() throws Exception {
-    DataSourceOperator.super.close();
-  }
-
   @Override
   public boolean isFinished() {
     return finished || (finished = !hasNext());
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanner.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanner.java
index 689745cb91..a6d1d16375 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanner.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanner.java
@@ -37,7 +37,7 @@ import org.apache.iotdb.db.mpp.execution.driver.SchemaDriverContext;
 import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.mpp.execution.operator.Operator;
 import org.apache.iotdb.db.mpp.execution.operator.OperatorContext;
-import org.apache.iotdb.db.mpp.execution.operator.process.AggregateOperator;
+import org.apache.iotdb.db.mpp.execution.operator.process.AggregationOperator;
 import org.apache.iotdb.db.mpp.execution.operator.process.DeviceMergeOperator;
 import org.apache.iotdb.db.mpp.execution.operator.process.DeviceViewOperator;
 import org.apache.iotdb.db.mpp.execution.operator.process.FillOperator;
@@ -46,7 +46,7 @@ import org.apache.iotdb.db.mpp.execution.operator.process.LimitOperator;
 import org.apache.iotdb.db.mpp.execution.operator.process.LinearFillOperator;
 import org.apache.iotdb.db.mpp.execution.operator.process.OffsetOperator;
 import org.apache.iotdb.db.mpp.execution.operator.process.ProcessOperator;
-import org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregateOperator;
+import org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregationOperator;
 import org.apache.iotdb.db.mpp.execution.operator.process.TimeJoinOperator;
 import org.apache.iotdb.db.mpp.execution.operator.process.TransformOperator;
 import org.apache.iotdb.db.mpp.execution.operator.process.fill.IFill;
@@ -86,10 +86,11 @@ import org.apache.iotdb.db.mpp.execution.operator.schema.SchemaFetchScanOperator
 import org.apache.iotdb.db.mpp.execution.operator.schema.SchemaQueryMergeOperator;
 import org.apache.iotdb.db.mpp.execution.operator.schema.TimeSeriesCountOperator;
 import org.apache.iotdb.db.mpp.execution.operator.schema.TimeSeriesSchemaScanOperator;
+import org.apache.iotdb.db.mpp.execution.operator.source.AlignedSeriesAggregationScanOperator;
 import org.apache.iotdb.db.mpp.execution.operator.source.AlignedSeriesScanOperator;
 import org.apache.iotdb.db.mpp.execution.operator.source.DataSourceOperator;
 import org.apache.iotdb.db.mpp.execution.operator.source.ExchangeOperator;
-import org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregateScanOperator;
+import org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregationScanOperator;
 import org.apache.iotdb.db.mpp.execution.operator.source.SeriesScanOperator;
 import org.apache.iotdb.db.mpp.plan.analyze.TypeProvider;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.PlanNode;
@@ -121,6 +122,7 @@ import org.apache.iotdb.db.mpp.plan.planner.plan.node.process.SortNode;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.process.TimeJoinNode;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.process.TransformNode;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.sink.FragmentSinkNode;
+import org.apache.iotdb.db.mpp.plan.planner.plan.node.source.AlignedSeriesAggregationScanNode;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.source.AlignedSeriesScanNode;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.source.SeriesAggregationScanNode;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.source.SeriesScanNode;
@@ -139,6 +141,7 @@ import org.apache.commons.lang3.Validate;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -264,6 +267,48 @@ public class LocalExecutionPlanner {
       return seriesScanOperator;
     }
 
+    @Override
+    public Operator visitAlignedSeriesAggregationScan(
+        AlignedSeriesAggregationScanNode node, LocalExecutionPlanContext context) {
+      AlignedPath seriesPath = node.getAlignedPath();
+      boolean ascending = node.getScanOrder() == OrderBy.TIMESTAMP_ASC;
+      OperatorContext operatorContext =
+          context.instanceContext.addOperatorContext(
+              context.getNextOperatorId(),
+              node.getPlanNodeId(),
+              AlignedSeriesAggregationScanOperator.class.getSimpleName());
+      List<Aggregator> aggregators = new ArrayList<>();
+      for (AggregationDescriptor descriptor : node.getAggregationDescriptorList()) {
+        // I am not sure that it's correct or not
+        String inputSeries = descriptor.getParametersString();
+        int seriesIndex = seriesPath.getMeasurementList().indexOf(inputSeries);
+        TSDataType seriesDataType =
+            seriesPath.getMeasurementSchema().getSubMeasurementsTSDataTypeList().get(seriesIndex);
+        aggregators.add(
+            new Aggregator(
+                AccumulatorFactory.createAccumulator(
+                    descriptor.getAggregationType(), seriesDataType, ascending),
+                descriptor.getStep(),
+                Collections.singletonList(
+                    new InputLocation[] {new InputLocation(0, seriesIndex)})));
+      }
+
+      AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+          new AlignedSeriesAggregationScanOperator(
+              node.getPlanNodeId(),
+              seriesPath,
+              operatorContext,
+              aggregators,
+              node.getTimeFilter(),
+              ascending,
+              node.getGroupByTimeParameter());
+
+      context.addSourceOperator(seriesAggregationScanOperator);
+      context.addPath(seriesPath);
+
+      return seriesAggregationScanOperator;
+    }
+
     @Override
     public Operator visitSchemaQueryScan(
         SchemaQueryScanNode node, LocalExecutionPlanContext context) {
@@ -452,8 +497,8 @@ public class LocalExecutionPlanner {
                               node.getSeriesPath().getSeriesType(),
                               ascending),
                           o.getStep())));
-      SeriesAggregateScanOperator aggregateScanOperator =
-          new SeriesAggregateScanOperator(
+      SeriesAggregationScanOperator aggregateScanOperator =
+          new SeriesAggregationScanOperator(
               node.getPlanNodeId(),
               seriesPath,
               context.getAllSensors(seriesPath.getDevice(), seriesPath.getMeasurement()),
@@ -784,14 +829,14 @@ public class LocalExecutionPlanner {
       boolean inputRaw = node.getAggregationDescriptorList().get(0).getStep().isInputRaw();
       if (inputRaw) {
         checkArgument(children.size() == 1, "rawDataAggregateOperator can only accept one input");
-        return new RawDataAggregateOperator(
+        return new RawDataAggregationOperator(
             operatorContext,
             aggregators,
             children.get(0),
             ascending,
             node.getGroupByTimeParameter());
       } else {
-        return new AggregateOperator(
+        return new AggregationOperator(
             operatorContext, aggregators, children, ascending, node.getGroupByTimeParameter());
       }
     }
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/PlanVisitor.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/PlanVisitor.java
index 2cab8c04d4..53132f3d0c 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/PlanVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/PlanVisitor.java
@@ -81,7 +81,7 @@ public abstract class PlanVisitor<R, C> {
     return visitPlan(node, context);
   }
 
-  public R visitAlignedSeriesAggregate(AlignedSeriesAggregationScanNode node, C context) {
+  public R visitAlignedSeriesAggregationScan(AlignedSeriesAggregationScanNode node, C context) {
     return visitPlan(node, context);
   }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
index c57e6692b5..0345031d07 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
@@ -27,6 +27,7 @@ import org.apache.iotdb.db.mpp.plan.planner.plan.node.PlanNode;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.PlanNodeId;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.PlanNodeType;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.PlanVisitor;
+import org.apache.iotdb.db.mpp.plan.planner.plan.node.process.AggregationNode;
 import org.apache.iotdb.db.mpp.plan.planner.plan.parameter.AggregationDescriptor;
 import org.apache.iotdb.db.mpp.plan.planner.plan.parameter.GroupByTimeParameter;
 import org.apache.iotdb.db.mpp.plan.statement.component.OrderBy;
@@ -74,7 +75,8 @@ public class AlignedSeriesAggregationScanNode extends SourceNode {
       List<AggregationDescriptor> aggregationDescriptorList) {
     super(id);
     this.alignedPath = alignedPath;
-    this.aggregationDescriptorList = aggregationDescriptorList;
+    this.aggregationDescriptorList =
+        AggregationNode.getDeduplicatedDescriptors(aggregationDescriptorList);
   }
 
   public AlignedSeriesAggregationScanNode(
@@ -181,7 +183,7 @@ public class AlignedSeriesAggregationScanNode extends SourceNode {
 
   @Override
   public <R, C> R accept(PlanVisitor<R, C> visitor, C context) {
-    return visitor.visitAlignedSeriesAggregate(this, context);
+    return visitor.visitAlignedSeriesAggregationScan(this, context);
   }
 
   @Override
diff --git a/server/src/main/java/org/apache/iotdb/db/query/executor/groupby/impl/LocalAlignedGroupByExecutor.java b/server/src/main/java/org/apache/iotdb/db/query/executor/groupby/impl/LocalAlignedGroupByExecutor.java
index 9a47eaad0a..aa5ede9abd 100644
--- a/server/src/main/java/org/apache/iotdb/db/query/executor/groupby/impl/LocalAlignedGroupByExecutor.java
+++ b/server/src/main/java/org/apache/iotdb/db/query/executor/groupby/impl/LocalAlignedGroupByExecutor.java
@@ -246,9 +246,7 @@ public class LocalAlignedGroupByExecutor implements AlignedGroupByExecutor {
 
       // set initial Index
       lastReadCurArrayIndex = batchData.getReadCurArrayIndex();
-      ;
       lastReadCurListIndex = batchData.getReadCurListIndex();
-      ;
 
       // stop calc and cached current batchData
       if (ascending && batchData.currentTime() >= curEndTime) {
diff --git a/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/AggregateOperatorTest.java b/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/AggregationOperatorTest.java
similarity index 87%
rename from server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/AggregateOperatorTest.java
rename to server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/AggregationOperatorTest.java
index d4a3392e97..eaf58a6f22 100644
--- a/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/AggregateOperatorTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/AggregationOperatorTest.java
@@ -33,8 +33,8 @@ import org.apache.iotdb.db.mpp.common.PlanFragmentId;
 import org.apache.iotdb.db.mpp.common.QueryId;
 import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceStateMachine;
-import org.apache.iotdb.db.mpp.execution.operator.process.AggregateOperator;
-import org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregateScanOperator;
+import org.apache.iotdb.db.mpp.execution.operator.process.AggregationOperator;
+import org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregationScanOperator;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.PlanNodeId;
 import org.apache.iotdb.db.mpp.plan.planner.plan.parameter.AggregationStep;
 import org.apache.iotdb.db.mpp.plan.planner.plan.parameter.GroupByTimeParameter;
@@ -59,9 +59,9 @@ import java.util.concurrent.ExecutorService;
 import static org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceContext.createFragmentInstanceContext;
 import static org.junit.Assert.assertEquals;
 
-public class AggregateOperatorTest {
+public class AggregationOperatorTest {
 
-  private static final String AGGREGATE_OPERATOR_TEST_SG = "root.AggregateOperatorTest";
+  private static final String AGGREGATION_OPERATOR_TEST_SG = "root.AggregationOperatorTest";
   private final List<String> deviceIds = new ArrayList<>();
   private final List<MeasurementSchema> measurementSchemas = new ArrayList<>();
 
@@ -73,7 +73,7 @@ public class AggregateOperatorTest {
   @Before
   public void setUp() throws MetadataException, IOException, WriteProcessException {
     SeriesReaderTestUtil.setUp(
-        measurementSchemas, deviceIds, seqResources, unSeqResources, AGGREGATE_OPERATOR_TEST_SG);
+        measurementSchemas, deviceIds, seqResources, unSeqResources, AGGREGATION_OPERATOR_TEST_SG);
     this.instanceNotificationExecutor =
         IoTDBThreadPoolFactory.newFixedThreadPool(1, "test-instance-notification");
   }
@@ -101,11 +101,11 @@ public class AggregateOperatorTest {
       inputLocationForOneAggregator.add(new InputLocation[] {new InputLocation(1, i)});
       inputLocations.add(inputLocationForOneAggregator);
     }
-    AggregateOperator aggregateOperator =
-        initAggregateOperator(aggregationTypes, null, inputLocations);
+    AggregationOperator aggregationOperator =
+        initAggregationOperator(aggregationTypes, null, inputLocations);
     int count = 0;
-    while (aggregateOperator.hasNext()) {
-      TsBlock resultTsBlock = aggregateOperator.next();
+    while (aggregationOperator.hasNext()) {
+      TsBlock resultTsBlock = aggregationOperator.next();
       assertEquals(500, resultTsBlock.getColumn(0).getLong(0));
       assertEquals(6524750.0, resultTsBlock.getColumn(1).getDouble(0), 0.0001);
       assertEquals(0, resultTsBlock.getColumn(2).getLong(0));
@@ -133,11 +133,11 @@ public class AggregateOperatorTest {
           new InputLocation[] {new InputLocation(1, 2 * i), new InputLocation(1, 2 * i + 1)});
       inputLocations.add(inputLocationForOneAggregator);
     }
-    AggregateOperator aggregateOperator =
-        initAggregateOperator(aggregationTypes, null, inputLocations);
+    AggregationOperator aggregationOperator =
+        initAggregationOperator(aggregationTypes, null, inputLocations);
     int count = 0;
-    while (aggregateOperator.hasNext()) {
-      TsBlock resultTsBlock = aggregateOperator.next();
+    while (aggregationOperator.hasNext()) {
+      TsBlock resultTsBlock = aggregationOperator.next();
       assertEquals(13049.5, resultTsBlock.getColumn(0).getDouble(0), 0.001);
       assertEquals(20000, resultTsBlock.getColumn(1).getInt(0));
       assertEquals(10499, resultTsBlock.getColumn(2).getInt(0));
@@ -172,11 +172,11 @@ public class AggregateOperatorTest {
       inputLocationForOneAggregator.add(new InputLocation[] {new InputLocation(1, i)});
       inputLocations.add(inputLocationForOneAggregator);
     }
-    AggregateOperator aggregateOperator =
-        initAggregateOperator(aggregationTypes, groupByTimeParameter, inputLocations);
+    AggregationOperator aggregationOperator =
+        initAggregationOperator(aggregationTypes, groupByTimeParameter, inputLocations);
     int count = 0;
-    while (aggregateOperator.hasNext()) {
-      TsBlock resultTsBlock = aggregateOperator.next();
+    while (aggregationOperator.hasNext()) {
+      TsBlock resultTsBlock = aggregationOperator.next();
       assertEquals(100 * count, resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[0][count], resultTsBlock.getColumn(0).getLong(0));
       assertEquals(result[1][count], resultTsBlock.getColumn(1).getDouble(0), 0.0001);
@@ -211,11 +211,11 @@ public class AggregateOperatorTest {
           new InputLocation[] {new InputLocation(1, 2 * i), new InputLocation(1, 2 * i + 1)});
       inputLocations.add(inputLocationForOneAggregator);
     }
-    AggregateOperator aggregateOperator =
-        initAggregateOperator(aggregationTypes, groupByTimeParameter, inputLocations);
+    AggregationOperator aggregationOperator =
+        initAggregationOperator(aggregationTypes, groupByTimeParameter, inputLocations);
     int count = 0;
-    while (aggregateOperator.hasNext()) {
-      TsBlock resultTsBlock = aggregateOperator.next();
+    while (aggregationOperator.hasNext()) {
+      TsBlock resultTsBlock = aggregationOperator.next();
       assertEquals(100 * count, resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[0][count], resultTsBlock.getColumn(0).getDouble(0), 0.001);
       assertEquals((int) result[1][count], resultTsBlock.getColumn(1).getInt(0));
@@ -230,7 +230,7 @@ public class AggregateOperatorTest {
    * @param groupByTimeParameter group by time parameter
    * @param inputLocations each inputLocation is used in one aggregator
    */
-  private AggregateOperator initAggregateOperator(
+  private AggregationOperator initAggregationOperator(
       List<AggregationType> aggregationTypes,
       GroupByTimeParameter groupByTimeParameter,
       List<List<InputLocation[]>> inputLocations)
@@ -245,21 +245,21 @@ public class AggregateOperatorTest {
         createFragmentInstanceContext(instanceId, stateMachine);
     PlanNodeId planNodeId1 = new PlanNodeId("1");
     fragmentInstanceContext.addOperatorContext(
-        1, planNodeId1, SeriesAggregateScanOperator.class.getSimpleName());
+        1, planNodeId1, SeriesAggregationScanOperator.class.getSimpleName());
     PlanNodeId planNodeId2 = new PlanNodeId("2");
     fragmentInstanceContext.addOperatorContext(
-        2, planNodeId2, SeriesAggregateScanOperator.class.getSimpleName());
+        2, planNodeId2, SeriesAggregationScanOperator.class.getSimpleName());
     PlanNodeId planNodeId3 = new PlanNodeId("3");
     fragmentInstanceContext.addOperatorContext(
-        3, planNodeId3, AggregateOperator.class.getSimpleName());
+        3, planNodeId3, AggregationOperator.class.getSimpleName());
 
     MeasurementPath measurementPath1 =
-        new MeasurementPath(AGGREGATE_OPERATOR_TEST_SG + ".device0.sensor0", TSDataType.INT32);
+        new MeasurementPath(AGGREGATION_OPERATOR_TEST_SG + ".device0.sensor0", TSDataType.INT32);
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.PARTIAL)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator1 =
-        new SeriesAggregateScanOperator(
+    SeriesAggregationScanOperator seriesAggregationScanOperator1 =
+        new SeriesAggregationScanOperator(
             planNodeId1,
             measurementPath1,
             Collections.singleton("sensor0"),
@@ -277,11 +277,11 @@ public class AggregateOperatorTest {
     unSeqResources1.add(unSeqResources.get(1));
     unSeqResources1.add(unSeqResources.get(3));
     unSeqResources1.add(unSeqResources.get(5));
-    seriesAggregateScanOperator1.initQueryDataSource(
+    seriesAggregationScanOperator1.initQueryDataSource(
         new QueryDataSource(seqResources1, unSeqResources1));
 
-    SeriesAggregateScanOperator seriesAggregateScanOperator2 =
-        new SeriesAggregateScanOperator(
+    SeriesAggregationScanOperator seriesAggregationScanOperator2 =
+        new SeriesAggregationScanOperator(
             planNodeId2,
             measurementPath1,
             Collections.singleton("sensor0"),
@@ -296,12 +296,12 @@ public class AggregateOperatorTest {
     seqResources2.add(seqResources.get(4));
     unSeqResources2.add(unSeqResources.get(2));
     unSeqResources2.add(unSeqResources.get(4));
-    seriesAggregateScanOperator2.initQueryDataSource(
+    seriesAggregationScanOperator2.initQueryDataSource(
         new QueryDataSource(seqResources2, unSeqResources2));
 
     List<Operator> children = new ArrayList<>();
-    children.add(seriesAggregateScanOperator1);
-    children.add(seriesAggregateScanOperator2);
+    children.add(seriesAggregationScanOperator1);
+    children.add(seriesAggregationScanOperator2);
 
     List<Aggregator> finalAggregators = new ArrayList<>();
     List<Accumulator> accumulators =
@@ -311,7 +311,7 @@ public class AggregateOperatorTest {
           new Aggregator(accumulators.get(i), AggregationStep.FINAL, inputLocations.get(i)));
     }
 
-    return new AggregateOperator(
+    return new AggregationOperator(
         fragmentInstanceContext.getOperatorContexts().get(2),
         finalAggregators,
         children,
diff --git a/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/SeriesAggregateScanOperatorTest.java b/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/AlignedSeriesAggregationScanOperatorTest.java
similarity index 50%
copy from server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/SeriesAggregateScanOperatorTest.java
copy to server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/AlignedSeriesAggregationScanOperatorTest.java
index 1c7a77ded6..fbd76ab819 100644
--- a/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/SeriesAggregateScanOperatorTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/AlignedSeriesAggregationScanOperatorTest.java
@@ -7,7 +7,7 @@
  * "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
@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+
 package org.apache.iotdb.db.mpp.execution.operator;
 
 import org.apache.iotdb.commons.concurrent.IoTDBThreadPoolFactory;
@@ -23,33 +24,33 @@ import org.apache.iotdb.commons.exception.IllegalPathException;
 import org.apache.iotdb.commons.exception.MetadataException;
 import org.apache.iotdb.db.engine.querycontext.QueryDataSource;
 import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
-import org.apache.iotdb.db.metadata.path.MeasurementPath;
+import org.apache.iotdb.db.metadata.path.AlignedPath;
 import org.apache.iotdb.db.mpp.aggregation.AccumulatorFactory;
 import org.apache.iotdb.db.mpp.aggregation.Aggregator;
 import org.apache.iotdb.db.mpp.common.FragmentInstanceId;
 import org.apache.iotdb.db.mpp.common.PlanFragmentId;
 import org.apache.iotdb.db.mpp.common.QueryId;
 import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceContext;
-import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceState;
 import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceStateMachine;
-import org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregateScanOperator;
+import org.apache.iotdb.db.mpp.execution.operator.source.AlignedSeriesAggregationScanOperator;
 import org.apache.iotdb.db.mpp.execution.operator.source.SeriesScanOperator;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.PlanNodeId;
 import org.apache.iotdb.db.mpp.plan.planner.plan.parameter.AggregationStep;
 import org.apache.iotdb.db.mpp.plan.planner.plan.parameter.GroupByTimeParameter;
+import org.apache.iotdb.db.mpp.plan.planner.plan.parameter.InputLocation;
 import org.apache.iotdb.db.query.aggregation.AggregationType;
-import org.apache.iotdb.db.query.reader.series.SeriesReaderTestUtil;
 import org.apache.iotdb.tsfile.exception.write.WriteProcessException;
 import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
 import org.apache.iotdb.tsfile.read.common.block.TsBlock;
 import org.apache.iotdb.tsfile.read.filter.TimeFilter;
 import org.apache.iotdb.tsfile.read.filter.basic.Filter;
 import org.apache.iotdb.tsfile.read.filter.operator.AndFilter;
+import org.apache.iotdb.tsfile.write.schema.IMeasurementSchema;
 import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
 
 import com.google.common.collect.Sets;
-import org.junit.After;
-import org.junit.Before;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.io.IOException;
@@ -58,47 +59,57 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
 
 import static org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceContext.createFragmentInstanceContext;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class AlignedSeriesAggregationScanOperatorTest {
 
-public class SeriesAggregateScanOperatorTest {
+  private static final String SERIES_AGGREGATION_SCAN_OPERATOR_TEST_SG =
+      "root.AlignedSeriesAggregationScanOperatorTest";
+  private static final List<MeasurementSchema> measurementSchemas = new ArrayList<>();
 
-  private static final String SERIES_SCAN_OPERATOR_TEST_SG = "root.SeriesScanOperatorTest";
-  private final List<String> deviceIds = new ArrayList<>();
-  private final List<MeasurementSchema> measurementSchemas = new ArrayList<>();
+  private static final List<TsFileResource> seqResources = new ArrayList<>();
+  private static final List<TsFileResource> unSeqResources = new ArrayList<>();
 
-  private final List<TsFileResource> seqResources = new ArrayList<>();
-  private final List<TsFileResource> unSeqResources = new ArrayList<>();
-  private ExecutorService instanceNotificationExecutor;
+  private ExecutorService instanceNotificationExecutor =
+      IoTDBThreadPoolFactory.newFixedThreadPool(1, "test-instance-notification");;
+  private static final double DELTA = 0.000001;
 
-  @Before
-  public void setUp() throws MetadataException, IOException, WriteProcessException {
-    SeriesReaderTestUtil.setUp(
-        measurementSchemas, deviceIds, seqResources, unSeqResources, SERIES_SCAN_OPERATOR_TEST_SG);
-    this.instanceNotificationExecutor =
-        IoTDBThreadPoolFactory.newFixedThreadPool(1, "test-instance-notification");
+  @BeforeClass
+  public static void setUp() throws MetadataException, IOException, WriteProcessException {
+    AlignedSeriesTestUtil.setUp(
+        measurementSchemas, seqResources, unSeqResources, SERIES_AGGREGATION_SCAN_OPERATOR_TEST_SG);
   }
 
-  @After
-  public void tearDown() throws IOException {
-    SeriesReaderTestUtil.tearDown(seqResources, unSeqResources);
-    instanceNotificationExecutor.shutdown();
+  @AfterClass
+  public static void tearDown() throws IOException {
+    AlignedSeriesTestUtil.tearDown(seqResources, unSeqResources);
   }
 
   @Test
   public void testAggregationWithoutTimeFilter() throws IllegalPathException {
-    List<AggregationType> aggregationTypes = Collections.singletonList(AggregationType.COUNT);
     List<Aggregator> aggregators = new ArrayList<>();
-    AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, null);
+    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(
+              AccumulatorFactory.createAccumulator(AggregationType.COUNT, dataType, true),
+              AggregationStep.SINGLE,
+              inputLocations));
+    }
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, null, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
-      assertEquals(500, resultTsBlock.getColumn(0).getLong(0));
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
+      for (int i = 0; i < measurementSchemas.size(); i++) {
+        assertEquals(500, resultTsBlock.getColumn(i).getLong(0));
+      }
       count++;
     }
     assertEquals(1, count);
@@ -106,16 +117,25 @@ public class SeriesAggregateScanOperatorTest {
 
   @Test
   public void testAggregationWithoutTimeFilterOrderByTimeDesc() throws IllegalPathException {
-    List<AggregationType> aggregationTypes = Collections.singletonList(AggregationType.COUNT);
     List<Aggregator> aggregators = new ArrayList<>();
-    AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, false, null);
+    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(
+              AccumulatorFactory.createAccumulator(AggregationType.COUNT, dataType, false),
+              AggregationStep.SINGLE,
+              inputLocations));
+    }
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, null, false, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
-      assertEquals(500, resultTsBlock.getColumn(0).getLong(0));
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
+      for (int i = 0; i < measurementSchemas.size(); i++) {
+        assertEquals(500, resultTsBlock.getColumn(i).getLong(0));
+      }
       count++;
     }
     assertEquals(1, count);
@@ -127,13 +147,21 @@ public class SeriesAggregateScanOperatorTest {
     aggregationTypes.add(AggregationType.COUNT);
     aggregationTypes.add(AggregationType.SUM);
     List<Aggregator> aggregators = new ArrayList<>();
-    AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, null);
+    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(
+              AccumulatorFactory.createAccumulator(aggregationTypes.get(i), dataType, true),
+              AggregationStep.SINGLE,
+              inputLocations));
+    }
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, null, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(500, resultTsBlock.getColumn(0).getLong(0));
       assertEquals(6524750.0, resultTsBlock.getColumn(1).getDouble(0), 0.0001);
       count++;
@@ -146,24 +174,32 @@ public class SeriesAggregateScanOperatorTest {
     List<AggregationType> aggregationTypes = new ArrayList<>();
     aggregationTypes.add(AggregationType.FIRST_VALUE);
     aggregationTypes.add(AggregationType.LAST_VALUE);
-    aggregationTypes.add(AggregationType.MIN_TIME);
-    aggregationTypes.add(AggregationType.MAX_TIME);
     aggregationTypes.add(AggregationType.MAX_VALUE);
     aggregationTypes.add(AggregationType.MIN_VALUE);
+    aggregationTypes.add(AggregationType.MIN_TIME);
+    aggregationTypes.add(AggregationType.MAX_TIME);
     List<Aggregator> aggregators = new ArrayList<>();
-    AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, null);
+    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(
+              AccumulatorFactory.createAccumulator(aggregationTypes.get(i), dataType, true),
+              AggregationStep.SINGLE,
+              inputLocations));
+    }
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, null, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
-      assertEquals(20000, resultTsBlock.getColumn(0).getInt(0));
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
+      assertTrue(resultTsBlock.getColumn(0).getBoolean(0));
       assertEquals(10499, resultTsBlock.getColumn(1).getInt(0));
-      assertEquals(0, resultTsBlock.getColumn(2).getLong(0));
-      assertEquals(499, resultTsBlock.getColumn(3).getLong(0));
-      assertEquals(20199, resultTsBlock.getColumn(4).getInt(0));
-      assertEquals(260, resultTsBlock.getColumn(5).getInt(0));
+      assertEquals(20199, resultTsBlock.getColumn(2).getLong(0));
+      assertEquals(260.0, resultTsBlock.getColumn(3).getFloat(0), DELTA);
+      assertEquals(0, resultTsBlock.getColumn(4).getLong(0));
+      assertEquals(499, resultTsBlock.getColumn(5).getLong(0));
       count++;
     }
     assertEquals(1, count);
@@ -175,24 +211,32 @@ public class SeriesAggregateScanOperatorTest {
     List<AggregationType> aggregationTypes = new ArrayList<>();
     aggregationTypes.add(AggregationType.FIRST_VALUE);
     aggregationTypes.add(AggregationType.LAST_VALUE);
-    aggregationTypes.add(AggregationType.MIN_TIME);
-    aggregationTypes.add(AggregationType.MAX_TIME);
     aggregationTypes.add(AggregationType.MAX_VALUE);
     aggregationTypes.add(AggregationType.MIN_VALUE);
+    aggregationTypes.add(AggregationType.MIN_TIME);
+    aggregationTypes.add(AggregationType.MAX_TIME);
     List<Aggregator> aggregators = new ArrayList<>();
-    AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, false)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, false, null);
+    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(
+              AccumulatorFactory.createAccumulator(aggregationTypes.get(i), dataType, false),
+              AggregationStep.SINGLE,
+              inputLocations));
+    }
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, null, false, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
-      assertEquals(20000, resultTsBlock.getColumn(0).getInt(0));
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
+      assertTrue(resultTsBlock.getColumn(0).getBoolean(0));
       assertEquals(10499, resultTsBlock.getColumn(1).getInt(0));
-      assertEquals(0, resultTsBlock.getColumn(2).getLong(0));
-      assertEquals(499, resultTsBlock.getColumn(3).getLong(0));
-      assertEquals(20199, resultTsBlock.getColumn(4).getInt(0));
-      assertEquals(260, resultTsBlock.getColumn(5).getInt(0));
+      assertEquals(20199, resultTsBlock.getColumn(2).getLong(0));
+      assertEquals(260.0, resultTsBlock.getColumn(3).getFloat(0), DELTA);
+      assertEquals(0, resultTsBlock.getColumn(4).getLong(0));
+      assertEquals(499, resultTsBlock.getColumn(5).getLong(0));
       count++;
     }
     assertEquals(1, count);
@@ -200,17 +244,26 @@ public class SeriesAggregateScanOperatorTest {
 
   @Test
   public void testAggregationWithTimeFilter1() throws IllegalPathException {
-    List<AggregationType> aggregationTypes = Collections.singletonList(AggregationType.COUNT);
     List<Aggregator> aggregators = new ArrayList<>();
-    AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+    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(
+              AccumulatorFactory.createAccumulator(AggregationType.COUNT, dataType, true),
+              AggregationStep.SINGLE,
+              inputLocations));
+    }
     Filter timeFilter = TimeFilter.gtEq(120);
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, timeFilter, true, null);
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
-      assertEquals(resultTsBlock.getColumn(0).getLong(0), 380);
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
+      for (int i = 0; i < measurementSchemas.size(); i++) {
+        assertEquals(resultTsBlock.getColumn(i).getLong(0), 380);
+      }
       count++;
     }
     assertEquals(1, count);
@@ -219,16 +272,25 @@ public class SeriesAggregateScanOperatorTest {
   @Test
   public void testAggregationWithTimeFilter2() throws IllegalPathException {
     Filter timeFilter = TimeFilter.ltEq(379);
-    List<AggregationType> aggregationTypes = Collections.singletonList(AggregationType.COUNT);
     List<Aggregator> aggregators = new ArrayList<>();
-    AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, timeFilter, true, null);
+    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(
+              AccumulatorFactory.createAccumulator(AggregationType.COUNT, dataType, true),
+              AggregationStep.SINGLE,
+              inputLocations));
+    }
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
-      assertEquals(resultTsBlock.getColumn(0).getLong(0), 380);
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
+      for (int i = 0; i < measurementSchemas.size(); i++) {
+        assertEquals(resultTsBlock.getColumn(i).getLong(0), 380);
+      }
       count++;
     }
     assertEquals(1, count);
@@ -237,16 +299,25 @@ public class SeriesAggregateScanOperatorTest {
   @Test
   public void testAggregationWithTimeFilter3() throws IllegalPathException {
     Filter timeFilter = new AndFilter(TimeFilter.gtEq(100), TimeFilter.ltEq(399));
-    List<AggregationType> aggregationTypes = Collections.singletonList(AggregationType.COUNT);
     List<Aggregator> aggregators = new ArrayList<>();
-    AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, timeFilter, true, null);
+    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(
+              AccumulatorFactory.createAccumulator(AggregationType.COUNT, dataType, true),
+              AggregationStep.SINGLE,
+              inputLocations));
+    }
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
-      assertEquals(resultTsBlock.getColumn(0).getLong(0), 300);
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
+      for (int i = 0; i < measurementSchemas.size(); i++) {
+        assertEquals(resultTsBlock.getColumn(i).getLong(0), 300);
+      }
       count++;
     }
     assertEquals(1, count);
@@ -257,25 +328,33 @@ public class SeriesAggregateScanOperatorTest {
     List<AggregationType> aggregationTypes = new ArrayList<>();
     aggregationTypes.add(AggregationType.FIRST_VALUE);
     aggregationTypes.add(AggregationType.LAST_VALUE);
-    aggregationTypes.add(AggregationType.MIN_TIME);
-    aggregationTypes.add(AggregationType.MAX_TIME);
     aggregationTypes.add(AggregationType.MAX_VALUE);
     aggregationTypes.add(AggregationType.MIN_VALUE);
+    aggregationTypes.add(AggregationType.MIN_TIME);
+    aggregationTypes.add(AggregationType.MAX_TIME);
     List<Aggregator> aggregators = new ArrayList<>();
-    AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
+    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(
+              AccumulatorFactory.createAccumulator(aggregationTypes.get(i), dataType, true),
+              AggregationStep.SINGLE,
+              inputLocations));
+    }
     Filter timeFilter = new AndFilter(TimeFilter.gtEq(100), TimeFilter.ltEq(399));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, timeFilter, true, null);
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
-      assertEquals(20100, resultTsBlock.getColumn(0).getInt(0));
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
+      assertTrue(resultTsBlock.getColumn(0).getBoolean(0));
       assertEquals(399, resultTsBlock.getColumn(1).getInt(0));
-      assertEquals(100, resultTsBlock.getColumn(2).getLong(0));
-      assertEquals(399, resultTsBlock.getColumn(3).getLong(0));
-      assertEquals(20199, resultTsBlock.getColumn(4).getInt(0));
-      assertEquals(260, resultTsBlock.getColumn(5).getInt(0));
+      assertEquals(20199, resultTsBlock.getColumn(2).getLong(0));
+      assertEquals(260.0, resultTsBlock.getColumn(3).getFloat(0), DELTA);
+      assertEquals(100, resultTsBlock.getColumn(4).getLong(0));
+      assertEquals(399, resultTsBlock.getColumn(5).getLong(0));
       count++;
     }
     assertEquals(1, count);
@@ -285,17 +364,26 @@ public class SeriesAggregateScanOperatorTest {
   public void testGroupByWithoutGlobalTimeFilter() throws IllegalPathException {
     int[] result = new int[] {100, 100, 100, 99};
     GroupByTimeParameter groupByTimeParameter = new GroupByTimeParameter(0, 399, 100, 100, true);
-    List<AggregationType> aggregationTypes = Collections.singletonList(AggregationType.COUNT);
     List<Aggregator> aggregators = new ArrayList<>();
-    AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, groupByTimeParameter);
+    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(
+              AccumulatorFactory.createAccumulator(AggregationType.COUNT, dataType, true),
+              AggregationStep.SINGLE,
+              inputLocations));
+    }
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(100 * count, resultTsBlock.getTimeColumn().getLong(0));
-      assertEquals(result[count], resultTsBlock.getColumn(0).getLong(0));
+      for (int i = 0; i < measurementSchemas.size(); i++) {
+        assertEquals(result[count], resultTsBlock.getColumn(i).getLong(0));
+      }
       count++;
     }
     assertEquals(4, count);
@@ -306,17 +394,27 @@ public class SeriesAggregateScanOperatorTest {
     int[] result = new int[] {0, 80, 100, 80};
     Filter timeFilter = new AndFilter(TimeFilter.gtEq(120), TimeFilter.ltEq(379));
     GroupByTimeParameter groupByTimeParameter = new GroupByTimeParameter(0, 399, 100, 100, true);
-    List<AggregationType> aggregationTypes = Collections.singletonList(AggregationType.COUNT);
     List<Aggregator> aggregators = new ArrayList<>();
-    AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, timeFilter, true, groupByTimeParameter);
+    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(
+              AccumulatorFactory.createAccumulator(AggregationType.COUNT, dataType, true),
+              AggregationStep.SINGLE,
+              inputLocations));
+    }
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(
+            aggregators, timeFilter, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(100 * count, resultTsBlock.getTimeColumn().getLong(0));
-      assertEquals(result[count], resultTsBlock.getColumn(0).getLong(0));
+      for (int i = 0; i < measurementSchemas.size(); i++) {
+        assertEquals(result[count], resultTsBlock.getColumn(i).getLong(0));
+      }
       count++;
     }
     assertEquals(4, count);
@@ -338,13 +436,15 @@ public class SeriesAggregateScanOperatorTest {
     aggregationTypes.add(AggregationType.MIN_VALUE);
     GroupByTimeParameter groupByTimeParameter = new GroupByTimeParameter(0, 399, 100, 100, true);
     List<Aggregator> aggregators = new ArrayList<>();
+    List<InputLocation[]> inputLocations =
+        Collections.singletonList(new InputLocation[] {new InputLocation(0, 1)});
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, groupByTimeParameter);
+        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE, inputLocations)));
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(100 * count, resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[0][count], resultTsBlock.getColumn(0).getInt(0));
       assertEquals(result[1][count], resultTsBlock.getColumn(1).getInt(0));
@@ -371,13 +471,15 @@ public class SeriesAggregateScanOperatorTest {
     aggregationTypes.add(AggregationType.MIN_VALUE);
     GroupByTimeParameter groupByTimeParameter = new GroupByTimeParameter(0, 399, 100, 100, true);
     List<Aggregator> aggregators = new ArrayList<>();
+    List<InputLocation[]> inputLocations =
+        Collections.singletonList(new InputLocation[] {new InputLocation(0, 1)});
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, false)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, false, groupByTimeParameter);
+        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE, inputLocations)));
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, null, false, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(100 * (3 - count), resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[0][3 - count], resultTsBlock.getColumn(0).getInt(0));
       assertEquals(result[1][3 - count], resultTsBlock.getColumn(1).getInt(0));
@@ -394,13 +496,15 @@ public class SeriesAggregateScanOperatorTest {
     GroupByTimeParameter groupByTimeParameter = new GroupByTimeParameter(0, 399, 100, 50, true);
     List<AggregationType> aggregationTypes = Collections.singletonList(AggregationType.COUNT);
     List<Aggregator> aggregators = new ArrayList<>();
+    List<InputLocation[]> inputLocations =
+        Collections.singletonList(new InputLocation[] {new InputLocation(0, 1)});
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, groupByTimeParameter);
+        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE, inputLocations)));
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(50 * count, resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[count], resultTsBlock.getColumn(0).getLong(0));
       count++;
@@ -415,13 +519,15 @@ public class SeriesAggregateScanOperatorTest {
     GroupByTimeParameter groupByTimeParameter = new GroupByTimeParameter(0, 149, 50, 30, true);
     List<AggregationType> aggregationTypes = Collections.singletonList(AggregationType.COUNT);
     List<Aggregator> aggregators = new ArrayList<>();
+    List<InputLocation[]> inputLocations =
+        Collections.singletonList(new InputLocation[] {new InputLocation(0, 1)});
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, groupByTimeParameter);
+        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE, inputLocations)));
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(timeColumn[count], resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[count], resultTsBlock.getColumn(0).getLong(0));
       count++;
@@ -446,13 +552,15 @@ public class SeriesAggregateScanOperatorTest {
     aggregationTypes.add(AggregationType.MIN_VALUE);
     GroupByTimeParameter groupByTimeParameter = new GroupByTimeParameter(0, 149, 50, 30, true);
     List<Aggregator> aggregators = new ArrayList<>();
+    List<InputLocation[]> inputLocations =
+        Collections.singletonList(new InputLocation[] {new InputLocation(0, 1)});
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
-        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, groupByTimeParameter);
+        .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE, inputLocations)));
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        initAlignedSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(timeColumn[count], resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[0][count], resultTsBlock.getColumn(0).getInt(0));
       assertEquals(result[1][count], resultTsBlock.getColumn(1).getInt(0));
@@ -463,18 +571,23 @@ public class SeriesAggregateScanOperatorTest {
     assertEquals(timeColumn.length, count);
   }
 
-  public SeriesAggregateScanOperator initSeriesAggregateScanOperator(
+  public AlignedSeriesAggregationScanOperator initAlignedSeriesAggregationScanOperator(
       List<Aggregator> aggregators,
       Filter timeFilter,
       boolean ascending,
       GroupByTimeParameter groupByTimeParameter)
       throws IllegalPathException {
-    MeasurementPath measurementPath =
-        new MeasurementPath(SERIES_SCAN_OPERATOR_TEST_SG + ".device0.sensor0", TSDataType.INT32);
+    AlignedPath alignedPath =
+        new AlignedPath(
+            SERIES_AGGREGATION_SCAN_OPERATOR_TEST_SG + ".device0",
+            measurementSchemas.stream()
+                .map(MeasurementSchema::getMeasurementId)
+                .collect(Collectors.toList()),
+            measurementSchemas.stream()
+                .map(m -> (IMeasurementSchema) m)
+                .collect(Collectors.toList()));
     Set<String> allSensors = Sets.newHashSet("sensor0");
     QueryId queryId = new QueryId("stub_query");
-    AtomicReference<FragmentInstanceState> state =
-        new AtomicReference<>(FragmentInstanceState.RUNNING);
     FragmentInstanceId instanceId =
         new FragmentInstanceId(new PlanFragmentId(queryId, 0), "stub-instance");
     FragmentInstanceStateMachine stateMachine =
@@ -485,18 +598,17 @@ public class SeriesAggregateScanOperatorTest {
     fragmentInstanceContext.addOperatorContext(
         1, planNodeId, SeriesScanOperator.class.getSimpleName());
 
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        new SeriesAggregateScanOperator(
+    AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
+        new AlignedSeriesAggregationScanOperator(
             planNodeId,
-            measurementPath,
-            allSensors,
+            alignedPath,
             fragmentInstanceContext.getOperatorContexts().get(0),
             aggregators,
             timeFilter,
             ascending,
             groupByTimeParameter);
-    seriesAggregateScanOperator.initQueryDataSource(
+    seriesAggregationScanOperator.initQueryDataSource(
         new QueryDataSource(seqResources, unSeqResources));
-    return seriesAggregateScanOperator;
+    return seriesAggregationScanOperator;
   }
 }
diff --git a/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/RawDataAggregateOperatorTest.java b/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/RawDataAggregationOperatorTest.java
similarity index 90%
rename from server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/RawDataAggregateOperatorTest.java
rename to server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/RawDataAggregationOperatorTest.java
index 0de2bd6b35..daed697a13 100644
--- a/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/RawDataAggregateOperatorTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/RawDataAggregationOperatorTest.java
@@ -33,7 +33,7 @@ import org.apache.iotdb.db.mpp.common.PlanFragmentId;
 import org.apache.iotdb.db.mpp.common.QueryId;
 import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceContext;
 import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceStateMachine;
-import org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregateOperator;
+import org.apache.iotdb.db.mpp.execution.operator.process.RawDataAggregationOperator;
 import org.apache.iotdb.db.mpp.execution.operator.process.TimeJoinOperator;
 import org.apache.iotdb.db.mpp.execution.operator.process.merge.AscTimeComparator;
 import org.apache.iotdb.db.mpp.execution.operator.process.merge.SingleColumnMerger;
@@ -65,9 +65,9 @@ import java.util.concurrent.ExecutorService;
 import static org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceContext.createFragmentInstanceContext;
 import static org.junit.Assert.assertEquals;
 
-public class RawDataAggregateOperatorTest {
+public class RawDataAggregationOperatorTest {
 
-  private static final String AGGREGATE_OPERATOR_TEST_SG = "root.RawDataAggregateOperatorTest";
+  private static final String AGGREGATION_OPERATOR_TEST_SG = "root.RawDataAggregationOperatorTest";
   private final List<String> deviceIds = new ArrayList<>();
   private final List<MeasurementSchema> measurementSchemas = new ArrayList<>();
 
@@ -78,7 +78,7 @@ public class RawDataAggregateOperatorTest {
   @Before
   public void setUp() throws MetadataException, IOException, WriteProcessException {
     SeriesReaderTestUtil.setUp(
-        measurementSchemas, deviceIds, seqResources, unSeqResources, AGGREGATE_OPERATOR_TEST_SG);
+        measurementSchemas, deviceIds, seqResources, unSeqResources, AGGREGATION_OPERATOR_TEST_SG);
     this.instanceNotificationExecutor =
         IoTDBThreadPoolFactory.newFixedThreadPool(1, "test-instance-notification");
   }
@@ -117,11 +117,11 @@ public class RawDataAggregateOperatorTest {
       }
     }
 
-    RawDataAggregateOperator rawDataAggregateOperator =
-        initRawDataAggregateOperator(aggregationTypes, null, inputLocations);
+    RawDataAggregationOperator rawDataAggregationOperator =
+        initRawDataAggregationOperator(aggregationTypes, null, inputLocations);
     int count = 0;
-    while (rawDataAggregateOperator.hasNext()) {
-      TsBlock resultTsBlock = rawDataAggregateOperator.next();
+    while (rawDataAggregationOperator.hasNext()) {
+      TsBlock resultTsBlock = rawDataAggregationOperator.next();
       for (int i = 0; i < 2; i++) {
         assertEquals(500, resultTsBlock.getColumn(6 * i).getLong(0));
         assertEquals(6524750.0, resultTsBlock.getColumn(6 * i + 1).getDouble(0), 0.0001);
@@ -167,11 +167,11 @@ public class RawDataAggregateOperatorTest {
       inputLocations.add(inputLocationForOneAggregator);
     }
 
-    RawDataAggregateOperator rawDataAggregateOperator =
-        initRawDataAggregateOperator(aggregationTypes, null, inputLocations);
+    RawDataAggregationOperator rawDataAggregationOperator =
+        initRawDataAggregationOperator(aggregationTypes, null, inputLocations);
     int count = 0;
-    while (rawDataAggregateOperator.hasNext()) {
-      TsBlock resultTsBlock = rawDataAggregateOperator.next();
+    while (rawDataAggregationOperator.hasNext()) {
+      TsBlock resultTsBlock = rawDataAggregationOperator.next();
       for (int i = 0; i < 2; i++) {
         assertEquals(13049.5, resultTsBlock.getColumn(i).getDouble(0), 0.001);
       }
@@ -215,11 +215,11 @@ public class RawDataAggregateOperatorTest {
     }
     GroupByTimeParameter groupByTimeParameter = new GroupByTimeParameter(0, 399, 100, 100, true);
 
-    RawDataAggregateOperator rawDataAggregateOperator =
-        initRawDataAggregateOperator(aggregationTypes, groupByTimeParameter, inputLocations);
+    RawDataAggregationOperator rawDataAggregationOperator =
+        initRawDataAggregationOperator(aggregationTypes, groupByTimeParameter, inputLocations);
     int count = 0;
-    while (rawDataAggregateOperator.hasNext()) {
-      TsBlock resultTsBlock = rawDataAggregateOperator.next();
+    while (rawDataAggregationOperator.hasNext()) {
+      TsBlock resultTsBlock = rawDataAggregationOperator.next();
       assertEquals(100 * count, resultTsBlock.getTimeColumn().getLong(0));
       for (int i = 0; i < 2; i++) {
         assertEquals(result[0][count], resultTsBlock.getColumn(6 * i).getLong(0));
@@ -264,11 +264,11 @@ public class RawDataAggregateOperatorTest {
       inputLocations.add(inputLocationForOneAggregator);
     }
     GroupByTimeParameter groupByTimeParameter = new GroupByTimeParameter(0, 399, 100, 100, true);
-    RawDataAggregateOperator rawDataAggregateOperator =
-        initRawDataAggregateOperator(aggregationTypes, groupByTimeParameter, inputLocations);
+    RawDataAggregationOperator rawDataAggregationOperator =
+        initRawDataAggregationOperator(aggregationTypes, groupByTimeParameter, inputLocations);
     int count = 0;
-    while (rawDataAggregateOperator.hasNext()) {
-      TsBlock resultTsBlock = rawDataAggregateOperator.next();
+    while (rawDataAggregationOperator.hasNext()) {
+      TsBlock resultTsBlock = rawDataAggregationOperator.next();
       assertEquals(100 * count, resultTsBlock.getTimeColumn().getLong(0));
       for (int i = 0; i < 2; i++) {
         assertEquals(result[0][count], resultTsBlock.getColumn(i).getDouble(0), 0.001);
@@ -284,7 +284,7 @@ public class RawDataAggregateOperatorTest {
     assertEquals(4, count);
   }
 
-  private RawDataAggregateOperator initRawDataAggregateOperator(
+  private RawDataAggregationOperator initRawDataAggregationOperator(
       List<AggregationType> aggregationTypes,
       GroupByTimeParameter groupByTimeParameter,
       List<List<InputLocation[]>> inputLocations)
@@ -293,7 +293,7 @@ public class RawDataAggregateOperatorTest {
         IoTDBThreadPoolFactory.newFixedThreadPool(1, "test-instance-notification");
 
     MeasurementPath measurementPath1 =
-        new MeasurementPath(AGGREGATE_OPERATOR_TEST_SG + ".device0.sensor0", TSDataType.INT32);
+        new MeasurementPath(AGGREGATION_OPERATOR_TEST_SG + ".device0.sensor0", TSDataType.INT32);
     Set<String> allSensors = new HashSet<>();
     allSensors.add("sensor0");
     allSensors.add("sensor1");
@@ -313,7 +313,7 @@ public class RawDataAggregateOperatorTest {
     fragmentInstanceContext.addOperatorContext(
         3, new PlanNodeId("3"), TimeJoinOperator.class.getSimpleName());
     fragmentInstanceContext.addOperatorContext(
-        4, new PlanNodeId("4"), RawDataAggregateOperatorTest.class.getSimpleName());
+        4, new PlanNodeId("4"), RawDataAggregationOperatorTest.class.getSimpleName());
     SeriesScanOperator seriesScanOperator1 =
         new SeriesScanOperator(
             planNodeId1,
@@ -327,7 +327,7 @@ public class RawDataAggregateOperatorTest {
     seriesScanOperator1.initQueryDataSource(new QueryDataSource(seqResources, unSeqResources));
 
     MeasurementPath measurementPath2 =
-        new MeasurementPath(AGGREGATE_OPERATOR_TEST_SG + ".device0.sensor1", TSDataType.INT32);
+        new MeasurementPath(AGGREGATION_OPERATOR_TEST_SG + ".device0.sensor1", TSDataType.INT32);
     SeriesScanOperator seriesScanOperator2 =
         new SeriesScanOperator(
             planNodeId2,
@@ -358,7 +358,7 @@ public class RawDataAggregateOperatorTest {
       aggregators.add(
           new Aggregator(accumulators.get(i), AggregationStep.SINGLE, inputLocations.get(i)));
     }
-    return new RawDataAggregateOperator(
+    return new RawDataAggregationOperator(
         fragmentInstanceContext.getOperatorContexts().get(3),
         aggregators,
         timeJoinOperator,
diff --git a/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/SeriesAggregateScanOperatorTest.java b/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/SeriesAggregationScanOperatorTest.java
similarity index 80%
rename from server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/SeriesAggregateScanOperatorTest.java
rename to server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/SeriesAggregationScanOperatorTest.java
index 1c7a77ded6..0c62a46328 100644
--- a/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/SeriesAggregateScanOperatorTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/SeriesAggregationScanOperatorTest.java
@@ -30,9 +30,8 @@ import org.apache.iotdb.db.mpp.common.FragmentInstanceId;
 import org.apache.iotdb.db.mpp.common.PlanFragmentId;
 import org.apache.iotdb.db.mpp.common.QueryId;
 import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceContext;
-import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceState;
 import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceStateMachine;
-import org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregateScanOperator;
+import org.apache.iotdb.db.mpp.execution.operator.source.SeriesAggregationScanOperator;
 import org.apache.iotdb.db.mpp.execution.operator.source.SeriesScanOperator;
 import org.apache.iotdb.db.mpp.plan.planner.plan.node.PlanNodeId;
 import org.apache.iotdb.db.mpp.plan.planner.plan.parameter.AggregationStep;
@@ -58,12 +57,11 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.atomic.AtomicReference;
 
 import static org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceContext.createFragmentInstanceContext;
 import static org.junit.Assert.assertEquals;
 
-public class SeriesAggregateScanOperatorTest {
+public class SeriesAggregationScanOperatorTest {
 
   private static final String SERIES_SCAN_OPERATOR_TEST_SG = "root.SeriesScanOperatorTest";
   private final List<String> deviceIds = new ArrayList<>();
@@ -93,11 +91,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, null);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, null, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(500, resultTsBlock.getColumn(0).getLong(0));
       count++;
     }
@@ -110,11 +108,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, false, null);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, null, false, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(500, resultTsBlock.getColumn(0).getLong(0));
       count++;
     }
@@ -129,11 +127,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, null);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, null, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(500, resultTsBlock.getColumn(0).getLong(0));
       assertEquals(6524750.0, resultTsBlock.getColumn(1).getDouble(0), 0.0001);
       count++;
@@ -153,11 +151,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, null);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, null, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(20000, resultTsBlock.getColumn(0).getInt(0));
       assertEquals(10499, resultTsBlock.getColumn(1).getInt(0));
       assertEquals(0, resultTsBlock.getColumn(2).getLong(0));
@@ -182,11 +180,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, false)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, false, null);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, null, false, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(20000, resultTsBlock.getColumn(0).getInt(0));
       assertEquals(10499, resultTsBlock.getColumn(1).getInt(0));
       assertEquals(0, resultTsBlock.getColumn(2).getLong(0));
@@ -205,11 +203,11 @@ public class SeriesAggregateScanOperatorTest {
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
     Filter timeFilter = TimeFilter.gtEq(120);
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, timeFilter, true, null);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(resultTsBlock.getColumn(0).getLong(0), 380);
       count++;
     }
@@ -223,11 +221,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, timeFilter, true, null);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(resultTsBlock.getColumn(0).getLong(0), 380);
       count++;
     }
@@ -241,11 +239,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, timeFilter, true, null);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(resultTsBlock.getColumn(0).getLong(0), 300);
       count++;
     }
@@ -265,11 +263,11 @@ public class SeriesAggregateScanOperatorTest {
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
     Filter timeFilter = new AndFilter(TimeFilter.gtEq(100), TimeFilter.ltEq(399));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, timeFilter, true, null);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, timeFilter, true, null);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(20100, resultTsBlock.getColumn(0).getInt(0));
       assertEquals(399, resultTsBlock.getColumn(1).getInt(0));
       assertEquals(100, resultTsBlock.getColumn(2).getLong(0));
@@ -289,11 +287,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, groupByTimeParameter);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(100 * count, resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[count], resultTsBlock.getColumn(0).getLong(0));
       count++;
@@ -310,11 +308,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, timeFilter, true, groupByTimeParameter);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, timeFilter, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(100 * count, resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[count], resultTsBlock.getColumn(0).getLong(0));
       count++;
@@ -340,11 +338,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, groupByTimeParameter);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(100 * count, resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[0][count], resultTsBlock.getColumn(0).getInt(0));
       assertEquals(result[1][count], resultTsBlock.getColumn(1).getInt(0));
@@ -373,11 +371,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, false)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, false, groupByTimeParameter);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, null, false, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(100 * (3 - count), resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[0][3 - count], resultTsBlock.getColumn(0).getInt(0));
       assertEquals(result[1][3 - count], resultTsBlock.getColumn(1).getInt(0));
@@ -396,11 +394,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, groupByTimeParameter);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(50 * count, resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[count], resultTsBlock.getColumn(0).getLong(0));
       count++;
@@ -417,11 +415,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, groupByTimeParameter);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(timeColumn[count], resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[count], resultTsBlock.getColumn(0).getLong(0));
       count++;
@@ -448,11 +446,11 @@ public class SeriesAggregateScanOperatorTest {
     List<Aggregator> aggregators = new ArrayList<>();
     AccumulatorFactory.createAccumulators(aggregationTypes, TSDataType.INT32, true)
         .forEach(o -> aggregators.add(new Aggregator(o, AggregationStep.SINGLE)));
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        initSeriesAggregateScanOperator(aggregators, null, true, groupByTimeParameter);
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        initSeriesAggregationScanOperator(aggregators, null, true, groupByTimeParameter);
     int count = 0;
-    while (seriesAggregateScanOperator.hasNext()) {
-      TsBlock resultTsBlock = seriesAggregateScanOperator.next();
+    while (seriesAggregationScanOperator.hasNext()) {
+      TsBlock resultTsBlock = seriesAggregationScanOperator.next();
       assertEquals(timeColumn[count], resultTsBlock.getTimeColumn().getLong(0));
       assertEquals(result[0][count], resultTsBlock.getColumn(0).getInt(0));
       assertEquals(result[1][count], resultTsBlock.getColumn(1).getInt(0));
@@ -463,7 +461,7 @@ public class SeriesAggregateScanOperatorTest {
     assertEquals(timeColumn.length, count);
   }
 
-  public SeriesAggregateScanOperator initSeriesAggregateScanOperator(
+  public SeriesAggregationScanOperator initSeriesAggregationScanOperator(
       List<Aggregator> aggregators,
       Filter timeFilter,
       boolean ascending,
@@ -473,8 +471,6 @@ public class SeriesAggregateScanOperatorTest {
         new MeasurementPath(SERIES_SCAN_OPERATOR_TEST_SG + ".device0.sensor0", TSDataType.INT32);
     Set<String> allSensors = Sets.newHashSet("sensor0");
     QueryId queryId = new QueryId("stub_query");
-    AtomicReference<FragmentInstanceState> state =
-        new AtomicReference<>(FragmentInstanceState.RUNNING);
     FragmentInstanceId instanceId =
         new FragmentInstanceId(new PlanFragmentId(queryId, 0), "stub-instance");
     FragmentInstanceStateMachine stateMachine =
@@ -485,8 +481,8 @@ public class SeriesAggregateScanOperatorTest {
     fragmentInstanceContext.addOperatorContext(
         1, planNodeId, SeriesScanOperator.class.getSimpleName());
 
-    SeriesAggregateScanOperator seriesAggregateScanOperator =
-        new SeriesAggregateScanOperator(
+    SeriesAggregationScanOperator seriesAggregationScanOperator =
+        new SeriesAggregationScanOperator(
             planNodeId,
             measurementPath,
             allSensors,
@@ -495,8 +491,8 @@ public class SeriesAggregateScanOperatorTest {
             timeFilter,
             ascending,
             groupByTimeParameter);
-    seriesAggregateScanOperator.initQueryDataSource(
+    seriesAggregationScanOperator.initQueryDataSource(
         new QueryDataSource(seqResources, unSeqResources));
-    return seriesAggregateScanOperator;
+    return seriesAggregationScanOperator;
   }
 }