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;
}
}